相关疑难解决方法(0)

我正在为我的库设计一个C++的异常层次结构."层次结构"是从std :: runtime_error派生的4个类.我想避免异常类的切片问题,因此使复制构造函数受到保护.但显然gcc需要在抛出它们的实例时调用复制构造函数,因此抱怨受保护的复制构造函数.Visual C++ 8.0编译相同的代码.是否有任何可移植的方法来解决异常类的切片问题？标准是否说明实现是否可以/应该要求抛出要抛出的类的复制构造函数？

比方说,我们有一个类层次结构,我们有一个通用Animal类,它有几类,从它直接继承(如Dog,Cat,Horse,等..).

在这个继承层次结构上使用模板时,使用SomeTemplateClass<Animal>然后将Dogs and Cats and Horses推入这个模板化对象是否合法？

例如,假设我们有一个模板化的Stack类,我们想要托管各种动物.我能说清楚吗？Stack<Animal> s; Dog d; s.push(d); Cat c; s.push(c);

我正在制作国际象棋游戏,我希望有一系列作品.

如果我是对的,在Java中你可以拥有一个抽象Piece类并拥有King或Queen扩展该类.如果我做的阵列Piece的I可以放置一个King数组中的一块地方和Queen在另一个地方,因为这两个部分King和Queen延伸Piece.

有没有办法用C++中的结构做到这一点？

我有这样的课程:

class Product
    {
        public :
            virtual double getPrice();
            virtual void setPrice(double price);
    };

class MusicProduct
    {
        protected:

            string author;
            double price;

        public :

            virtual string getAuthor();
            virtual void setAuthor(string author);
            ~MusicProduct();
    };

class CD : public MusicProduct, public Product
    {
        public :

            string getAuthor();
            void setAuthor(string author);
            double getPrice();
            void setPrice(double price);
    };

string CD::getAuthor()
    {
        return MusicProduct::author;
    }

    void CD::setAuthor(string author)
    {
        MusicProduct:author = author;
    }

    void setPrice(double price)
    {
    MusicProduct::price = price;
    }

    double getPrice()
    {
        return …

对于函数声明,如

ostream& operator<< (ostream& os, const unsigned char* s);

我想知道返回了什么.CPP引用表示它返回ostream对象.但为什么它是ostream而不是简单的ostream？

谢谢

假设以下代码:

class Event {
public:
    virtual void execute() {
        std::cout << "Event executed.";
    }
}

class SubEvent : public Event {
    void execute() {
        std::cout << "SubEvent executed.";
    }
}

void executeEvent(Event e) {
    e.execute();
}

int main(int argc, char ** argv) {
    SubEvent se;
    executeEvent(se);
}

执行时,程序输出"Event executed.",但我想执行SubEvent.我怎样才能做到这一点？

关于方法重写和OOP原则的有效性,我有一点混乱.我知道关于密封,阴影,覆盖,虚拟等的一切,但我遇到了一个场景,这让我很困惑.假设我有:

class classA
{

    public virtual void sayhello()

      {
        Console.WriteLine("hello I'm A");
    }

};

class classB :classA
{
    public override void sayhello()
    {
        Console.WriteLine("hello I'm B");
    }

};
class Program
{
    static void Main(string[] args)
    {

        classB a = new classB();
        a.sayhello();
    }
}

根据我到目前为止研究的所有内容,可以使用子类中的override关键字覆盖声明为virtual或abstract(在抽象类中)的方法.根据这个,上面的代码工作完美.当我删除virtual关键字,然后尝试使用override关键字覆盖该方法时,编译器会给出错误:

不能覆盖继承的成员'inheritence.classA.sayhello()',因为它没有标记为虚拟,抽象或覆盖

然后我从子类中删除了覆盖关键字,并将实现提供为:

class classB :classA
{
    public void sayhello()
    {
        Console.WriteLine("hello I'm B");
    }

};

在这种情况下,该方法可以被覆盖.我能够覆盖不是虚拟或抽象的方法.所以,我的问题是:

1. …

测试多态性和虚函数&shared_ptr,我试图理解下面的最小例子所描述的情况.

class B{
public:
  // Definition of class B
  virtual void someBMethod(){
   // Make a burger
  };
};

class C : public B {
public:
  // Definition of class C
  void someBMethod(){
   // Make a pizza
  };
};

class A{
public:
  A(B& SomeB) : Member(std::make_shared<B>(SomeB)){};
  std::shared_ptr<B> Member;
};

现在,我们可以拥有主力

int main(){
  C SomeC;
  A SomeA(SomeC);
  A.Member->someBMethod(); // someBMethod from B is being executed.
};

除非我不包括从我的实际代码的小例子,有些错误,我觉得SomeC是越来越切下来的B,或者至少someBMethod从B正在calledin的最后一行.

问:应该用什么来初始化正确的方式Member以这样的方式,该方法someBMethod从C …

我已经阅读了关于vtable的内容,并且已经理解了指向基类和派生类对象的基类指针的概念.有人可以解释当基类和派生类都是对象并且派生类对象被分配给基类对象时如何创建vtable的情况.以下示例中的案例3

#include <iostream>
#include <exception>
using namespace std;


class Base
{
public:
    virtual void function1() { cout<<"Base - func1"<<endl; }
    virtual void function2() { cout<<"Base - func2"<<endl; }
};

class Derived1: public Base
{
public:
    virtual void function1() { cout<<"Derived1 - func1"<<endl; }
};

class Derived2: public Base
{
public:
    virtual void function2() { cout<<"Derived2 - func2"<<endl; }
};

int main () 
{
    // Case 1
    Base* B1 = new Derived1();
    B1->function1();
    B1->function2();

    // Case 2
    cout<<endl;
    Base* B2 = …

C++ 专家兼 D 语言创始人Walter Bright表示：

切片问题很严重，因为它可能导致内存损坏，并且很难保证程序不会受到这种情况的影响。为了从语言中设计它，支持继承的类应该只能通过引用（而不是通过值）访问。D 编程语言具有这个特性。

如果有人通过给出一个 C++ 示例来解释它会更好，其中对象切片问题导致内存损坏？而这个问题用D语言是如何解决的呢？