相关疑难解决方法(0)

例:

template<class T>
class Base {
public:
    Base();
    friend class T;
};

现在这不起作用......有没有办法做到这一点？

我实际上是想制作一个像这样的通用类封口机:

class ClassSealer {
private:
   friend class Sealed;
   ClassSealer() {}
};
class Sealed : private virtual ClassSealer
{ 
   // ...
};
class FailsToDerive : public Sealed
{
   // Cannot be instantiated
};

我在这个网站上找到了这个例子,但我找不到它...(这里)

我知道还有其他方法可以做到这一点但是现在我很好奇你是否真的能做到这样的事情.

我一直在谷歌搜索,我只是找不到一个简单的答案.它应该很简单,就像STL一般.

我想定义从std :: ostream公开继承的MyOStream.假设我想在每次将某些内容写入流中时调用foo().

class MyOStream : public ostream {
public:
  ...
private:
   void foo() { ... }
}

我知道ostream的公共接口是非虚拟的,那怎么办呢？我希望客户能够在MyOStream上使用operator <<和write()以及put()并使用我的类的扩展功能.

正如我们从文献中了解到的公共继承一样,子类(子类)的对象也可以被视为基类(超类)的对象.为什么当继承受到保护或私有时,子类的对象不能被视为超类的对象？

那么有关于这个主题的足够信息.例如,这个线程对我来说非常清楚:私有,公共和受保护的继承之间的区别

除了一点; 为什么有用？

根据"C++编码标准"第32项中的描述,我有一个值类.简而言之,这意味着它提供了值语义,并且没有任何虚方法.

我不希望一个类派生自这个类.除了其他人之外,一个原因是它有一个公共的非虚拟析构函数.但是,基类应该具有公共和虚拟或受保护和非虚拟的析构函数.

我不知道写值类的可能性,因此不可能从中派生出来.我想在编译时禁止它.是否有任何已知的成语可以做到这一点？如果没有,或许在即将到来的C++ 0x中有一些新的可能性？还是有充分的理由说没有这种可能性？

可能重复:
我什么时候应该使用C++私有继承？

我想制作这个社区维基但没有看到按钮......有人可以添加它吗？

我无法想到我是以非公开的方式从一个类派生出来的,而且我无法回想起看到这样做的代码.

我想听一下它有用的真实世界的例子和模式.

class Base {
public:
   virtual void f() {}
};

class Derived : private Base {
public:
   void f() override {}
};

我的问题是这样的覆盖是否有用？私有继承意味着您不能存储Derived在Base指针中,因此永远不需要动态分派f到正确的类型.

我想使用组合并使用C++功能为每个可能的重载(noexcept,const,volatile)编写好的转发方法.

我们的想法是使用traits来确定方法是否被声明{noexcept/const/volatile/etc.}并相应地表现.

这是我想要实现的一个例子:

struct User{    
    UsedObject& obj;
    User(UsedObject& obj) : obj(obj) {}

    FORWARD_METHOD(obj, get); //here is where the forwarding happens
};

struct UsedObject{
    string m{"Hello\n"};

    string& get(double d){
        cout << "\tUsed :const not called...\n";
        return m;
    }
    const string& get(double d) const{
        cout << "\tUsed :const called...\n";
        return m;
    }
};

这是我到目前为止**:

// forward with noexcept attribute
// I'm not 100% sure about : std::declval<std::add_lvalue_reference<decltype(obj)>::type

template<typename... Args>
constexpr decltype(auto) get(Args && ... args)
noexcept(
         noexcept(std::declval<std::add_lvalue_reference<decltype(obj)>::type>().get(  std::forward<Args>(args)...  ))
         and
         std::is_nothrow_move_constructible<decltype( std::declval<std::add_lvalue_reference<decltype(obj)>::type>().get( …

是否可以指定父类的对齐？例如像(没有编译)的东西:

template<size_t n>
class Vector : public boost::array<double,n> __attribute__ ((aligned(16)))
{

谢谢

好吧,从我收集的评论来看,这不是一个好方法.我想我会坚持私有数组的组合/对齐

有人可以解释一下C++中究竟是私有/受保护的继承是什么,以及它要解决的问题是什么？

class Bar { };
class Foo : private Bar { };

我已经看过这个问题,但我仍然不明白它是什么,更何况我应该使用它.

(与Java/C#或类似语言中的功能比较也可能有所帮助.)

我正在学习OOP，似乎遇到了问题。
代码：

class line {
protected:
    double a;
public:

    line() {a = 1;}
    line(double var1) {a = var1;}
};

class rectangle: private line {
protected:
    double b;
public:
    double area() {return a * b;}

    rectangle():line() {b = 1;}
    rectangle(double var1):line(var1) {b = var1;}
    rectangle(double var1, double var2):line(var1) {b = var2;}
};

class parallelepiped: private rectangle{
private:
    double c;
public:
    double volume() {return area() * c;}
    void print() {  cout << "Parallelepiped rectangle information:" << endl;
                    cout << "a = " …

我需要一种方法让单个变量表示从同一基类派生的两种对象.

这有点难以描述,但我会尽力而为:

说基类:

class Rectangle
{
   float w;
   float h;
   const float area() {return w*h;}
};

以及两个派生类:

class Poker : Rectangle
{
    int style;  // Diamond, Club, ....
    int point;  // A~10, J, Q, K
};

class BusinessCard : Rectangle
{
    string name;
    string address;
    string phone;
};

现在可以声明一个对象,可以是扑克牌还是名片？

'因为下面的用法是非法的:

Rectangle* rec;
rec = new Poker();
delete rec;
rec = new BusinessCard();

多态可能是一种方式,但由于它只对改变基类的成员属性有好处,我需要这个对象能够准确地表示任何一个派生对象.

编辑:

谢谢你的所有答案.公共继承,虚拟析构函数甚至boost :: variant typedef都是很棒的提示.

我怎样才能做到这一点：

class Base
{
public:
    int a, b, c;
    void function();
    ...
};

class Derived1 : 
    private Base
{
public:
    int d, e, f;
    ...
};

class Derived2 :
    private Base
{
public:
    void addObject(const Base* obj);
    ...
};

请注意，我将其继承为私有

然后我想做这样的事情：

Base* d1 = new Derived1();
Base* d2 = new Derived2();

d2->addObject(d1);

这是我从编译器那里得到的相关问题：

C:\test\test.cpp||In function 'void init()':|
C:\test\test.cpp|423|error: no matching function for call to 'Derived2::addObject(const Base*)'|
C:\test\test.cpp|423|note: candidate is:|
C:\test\test.h|29|note: void Derived2::addObject(const Base*)|
C:\test\test.h|29|note:   no known conversion for argument …