Question

我正在研究一个试图实现独立基类（A）的项目，该基类可以在以后的类（例如B和C）中扩展。我希望能够独立地使用它们，因此没有纯虚函数，并且我只想在任何派生类中使用每个类的一个副本（因此虚拟对象可以避免使用Dreaded Diamond）。有些类，比如D，需要组合所有以前扩展的类，保留所有功能，同时实现其他类。

为了增加乐趣，我使用C ++ 03，gcc 4.4.6，并使其成为3.81。

一切都编译得很好，但是每当我尝试在派生类中使用基类函数时，我总是在链接上获得'未定义的'[基类函数]'的引用。

到目前为止我能找到的所有答案都是关于错误地实现纯虚函数，尝试使用构造函数，或者未能实现类的所有成员（因此存在vtable错误）。我不是（明知）做或打算做任何这些事情。

如果这些是作为模板实现的话会很酷，但遗憾的是由于复杂性而不可能。我无法发布实际代码，但我已经模拟了类似于基本结构和行为的示例：

声明类的头文件：

#ifndef CODE_H
#define CODE_H

class A
{
protected:
   int a_;
   int b_;
   int c_;

public:

   explicit A() :
      a_(0), b_(0), c_(0) {}

   A(const int X, const int Y, const int Z) :
      a_(X), b_(Y), c_(Z) {}

   A(const A& X) :
      a_(X.A()), b_(X.B()), c_(X.C()) {}

   int doA1(const A& X) const;

   int doA2() const;

   A getA() const;

   A& operator=(const A& X);

   const int& A() const {return a_;}
   const int& B() const {return b_;}
   const int& C() const {return c_;}

   //One for each operator but not shown for brevity
   A operator+(const A& X) const;
   void operator+=(const A& X);
   A operator+(const int X) const;
   void operator+=(const int X);
};

class B : public virtual A
{
protected:
   int d_;

public:

   explicit B() :
      A(), d_(0) {}

   B(const int D, A X) :
      A(X), d_(D) {}

   B(const int D) :
      d_(D) {}

   int doB1(const B& X) const;

   B getB() const;

   B& operator=(const B& X);

   const int& D() const {return d_;}

   //One for each operator but not shown for brevity.
   //int d_ doesn't need to be modified by the operators, so it's ignored in their implementation.
   B operator+(const B& X) const {return B(d_, (A::operator+(X.getA())));}
   void operator+=(const B& X)   {A::operator+=(X.getA());}
   B operator+(const int X) const; {return B(d_, (A::operator+(X)));}
   void operator+=(const int X)    {A::operator+(X);}
};

class C : public virtual A
{
protected:
   int e_;
   int f_;
   int g_;

public:

   explicit C() :
      A(), e_(0), f_(0), g_(0) {}

   C(const int U, const int V, const int W, 
     const int X, const int Y, const int Z) :
         A(U, V, W), e_(X), f_(Y), g_(Z) {}

   C(const A& W, 
     const int X, const int Y, const int Z) :
         A(W), e_(X), f_(Y), g_(Z) {}

   C(const C& X) :
         C(X.A(), X.B(), X.C()), e_(X.E()), f_(X.F()), g_(X.G()) {}

   int doC1(const C& X) const;

   C getC() const;

   C& operator=(const C& X);

   const int& E() const {return e_;}
   const int& F() const {return f_;}
   const int& G() const {return g_;}

   //One for each operator but not shown for brevity
   C operator+(const C& X) const;
   void operator+=(const C& X);
   C operator+(const int X) const;
   void operator+=(const int X);
};

class D : public virtual B, public virtual C
{
public:

   explicit D() :
      B(), C() {}

   D(const int D, C Y) :
      B(D), C(Y) {}

   int doD1(const D& X) const;

   int doD2() const;

   D getD() const;

   D& operator=(const D& X);

   //One for each operator but not shown for brevity.
   D operator+(const D& X) const {return D(d_, (C::operator+(X.getC())));}
   void operator+=(const D& X)   {C::operator+=(X.getC());}
   D operator+(const int X) const; {return D(d_, (C::operator+(X)));}
   void operator+=(const int X)    {C::operator+(X);}
};
#endif

文件实现A：

#include header.h

int A::doA1(const A& X) const
{
   int doStuff;
   //does stuff.
   return doStuff;
}

int A::doA2() const
{
   int doStuff2;
   //does stuff.
   return doStuff2;
}

A A::getA() const
{
   A out(a_, b_, c_);
   return out;
}

A& A::operator=(const A& X)
{
   if (this != &X)
   {
      a_ = X.a_;
      b_ = X.b_;
      c_ = X.c_;
   }
   return *this;
}

//One for each operator but not shown for brevity
A A::operator+(const A& X) const
{
   return A(a_ + X.a_, b_ + X.b_, c_ + X.c_);
}

void A::operator+=(const A& X)
{
   a_ += X.a_;
   b_ += X.b_;
   c_ += X.c_;
}   

 A A::operator+(const int X) const
{
   return A(a_ + X, b_ + X, c_ + X);
}

void A::operator+=(const int X)
{
   a_ += X;
   b_ += X;
   c_ += X;
}

实施B的文件：

#include header.h

int B::doB1(const B& X) const
{
   //Linker complains on both doA1 and getA, even if I qualify them or remove all the qualifiers
   return (A::doA1(X.getA()));
}

B B::getB() const
{
   //Also complains here, with or without qualifiers.
   B out(d_, A::getA());
   return out;
}

B& B::operator=(const B& X)
{
   if (this != &X)
   {
      //Also here, for presumably the same reason.
      A::operator=(D.getA());
      d_ = X.d_;
   }
   return *this;
}

我也可以为C和D提供模型，但它们遵循与A和B相同的基本模式。

根据我到目前为止看到的答案，我最多只需要在函数中添加基类限定符，以避免任何意外的名称隐藏，但这似乎不起作用。同样奇怪的是：实例化的对象似乎无法找到它们的公共函数（比如在doB1中）。我只是一个白痴错过了一些明显的东西（从C背景来看，我不会感到惊讶）？

Answer 1

您正在定义全局函数而不是类方法。

在class A

int doA1(const A& X) const;
int doA2() const;

Implemetation

int A::doA1(const A& X) const
int doA2() const

Thera在第二种情况下不是A::。

C ++链接时对基类函数的未定义引用（ - not-- vtables，构造函数，模板或纯虚函数）

1 个答案: