C++ 混淆分割错误_C++_Templates_Pointers_Segmentation Fault

C++ 混淆分割错误

c++ templates pointers

C++ 混淆分割错误,c++,templates,pointers,segmentation-fault,C++,Templates,Pointers,Segmentation Fault,编辑：我基本上修改了整个问题，以便提供一个可执行示例我一直有一个分段错误，我想不出来。这是我的代码的压缩版本。我维护了原始的类层次结构，尽管有些类没有相关的方法，因为我认为这与我的问题有关，特别是在我得到一些评论之后 #import <vector> using namespace std; template<class Data = float> class Vector { // All pure virtual functions. };

编辑：我基本上修改了整个问题，以便提供一个可执行示例

我一直有一个分段错误，我想不出来。这是我的代码的压缩版本。我维护了原始的类层次结构，尽管有些类没有相关的方法，因为我认为这与我的问题有关，特别是在我得到一些评论之后

#import <vector>
using namespace std;

template<class Data = float>
  class Vector
  {
    // All pure virtual functions.
  };

template<class Data>
  class TranslationVector : public virtual Vector<Data>
  {
    // All pure virtual functions.
  };

template<class Data>
  class SimpleVector4 : public virtual Vector<Data>
  {
    public:
      SimpleVector4(const Data d0, const Data d1, const Data d2, const Data d3)
      {
        fData = new vector<Data> ;

        fData->push_back(d0);
        fData->push_back(d1);
        fData->push_back(d2);
        fData->push_back(d3);
      }

      vector<Data>*
      getData()
      {
        return (fData);
      }

    private:
      vector<Data>* fData;
  };

template<class Data>
  class SimpleTranslationVector4 : public SimpleVector4<Data> , public TranslationVector<Data>
  {
    public:
      SimpleTranslationVector4(const Data x, const Data y, const Data z, const Data w) :
        SimpleVector4<Data> (x, y, z, w)
      {
      }
  };

template<class Data = float>
  class Matrix
  {
    // All pure virtual functions.
  };

template<class Data>
  class TransformationMatrix : public virtual Matrix<Data>
  {
    // All pure virtual functions.

    virtual void
    translate(TranslationVector<Data>* const translation) = 0;
  };

template<class Data>
  class SimpleMatrix44 : public virtual Matrix<Data>
  {
    public:
      SimpleMatrix44()
      {
        fData = new vector<Data> (CELLS_IN_MATRIX, 0);

        setIdentity();
      }

      vector<Data>*
      getData()
      {
        return (fData);
      }

      void
      setIdentity()
      {
        fData->at(0) = 1;
        fData->at(1) = 0;
        fData->at(2) = 0;
        fData->at(3) = 0;

        fData->at(4) = 0;
        fData->at(5) = 1;
        fData->at(6) = 0;
        fData->at(7) = 0;

        fData->at(8) = 0;
        fData->at(9) = 0;
        fData->at(10) = 1;
        fData->at(11) = 0;

        fData->at(12) = 0;
        fData->at(13) = 0;
        fData->at(14) = 0;
        fData->at(15) = 1;
      }

    private:
      static const int CELLS_IN_MATRIX = 16;

      vector<Data>* fData;
  };

template<class Data>
  class SimpleTransformationMatrix44 : public SimpleMatrix44<Data> , public TransformationMatrix<Data>
  {
    public:
      SimpleTransformationMatrix44() :
        SimpleMatrix44<Data> ()
      {
      }

      void
      translate(TranslationVector<Data>* translation)
      {
        vector<Data> *data = SimpleMatrix44<Data>::getData();
        vector<Data> *transData = ((SimpleVector4<Data>*) translation)->getData();

        // The error occurs on this line:
        data->at(12) += data->at(0) * transData->at(0) + data->at(4) * transData->at(1) + data->at(8) * transData->at(2);
        data->at(13) += data->at(1) * transData->at(0) + data->at(5) * transData->at(1) + data->at(9) * transData->at(2);
        data->at(14) += data->at(2) * transData->at(0) + data->at(6) * transData->at(1) + data->at(10) * transData->at(2);
        data->at(15) += data->at(3) * transData->at(0) + data->at(7) * transData->at(1) + data->at(11) * transData->at(2);
      }
  };

int
main(int argc, char** argv)
{
  SimpleTransformationMatrix44<float> matrix1;
  matrix1.translate(new SimpleTranslationVector4<float> (0.0f, 10.0f, 0.0f, 1.0f));

  return 0;
}

#导入
使用名称空间std；
样板
类向量
{
//所有纯虚函数。
};
样板
类TranslationVector：公共虚拟向量
{
//所有纯虚函数。
};
样板
类SimpleVector4：公共虚拟向量
{
公众：
SimpleVector4（常数数据d0、常数数据d1、常数数据d2、常数数据d3）
{
fData=新向量；
fData->推回（d0）；
fData->推回（d1）；
fData->推回（d2）；
fData->推回（d3）；
}
载体*
getData（）
{
返回（fData）；
}
私人：
向量*fData；
};
样板
类SimpleTranslationVector4:PublicSimpleVector4，PublicTranslationVector
{
公众：
SimpleTranslationVector4（常量数据x、常量数据y、常量数据z、常量数据w）：
SimpleVector4（x，y，z，w）
{
}
};
样板
类矩阵
{
//所有纯虚函数。
};
样板
类转换矩阵：公共虚拟矩阵
{
//所有纯虚函数。
虚空
translate（TranslationVector*const translation）=0；
};
样板
类SimpleMatrix X44：公共虚拟矩阵
{
公众：
SimpleMatrix X44（）
{
fData=新向量（矩阵中的单元格，0）；
setIdentity（）；
}
载体*
getData（）
{
返回（fData）；
}
无效的
setIdentity（）
{
fData->at（0）=1；
fData->at（1）=0；
fData->at（2）=0；
fData->at（3）=0；
fData->at（4）=0；
fData->at（5）=1；
fData->at（6）=0；
fData->at（7）=0；
fData->at（8）=0；
fData->at（9）=0；
fData->at（10）=1；
fData->at（11）=0；
fData->at（12）=0；
fData->at（13）=0；
fData->at（14）=0；
fData->at（15）=1；
}
私人：
矩阵中的静态常量int单元格=16；
向量*fData；
};
样板
类SimpleTransformationMatrix44:public SimpleMatrix44，public TransformationMatrix
{
公众：
SimpleTransformationMatrix44（）：
SimpleMatrix X44（）
{
}
无效的
翻译（翻译向量*翻译）
{
vector*data=SimpleMatrix x44:：getData（）；
vector*transData=（（SimpleVector4*）translation）->getData（）；
//错误发生在这一行：
数据->在（12）+=数据->在（0）*传输数据->在（0）+数据->在（4）*传输数据->在（1）+数据->在（8）*传输数据->在（2）；
数据->在（13）+=数据->在（1）*传输数据->在（0）+数据->在（5）*传输数据->在（1）+数据->在（9）*传输数据->在（2）；
数据->在（14）+=数据->在（2）*传输数据->在（0）+数据->在（6）*传输数据->在（1）+数据->在（10）*传输数据->在（2）；
数据->在（15）+=数据->在（3）*传输数据->在（0）+数据->在（7）*传输数据->在（1）+数据->在（11）*传输数据->在（2）；
}
};
int
主（内部argc，字符**argv）
{
简单转换矩阵X44矩阵X1；
矩阵1.translate（新的SimpleTranslationVector4（0.0f，10.0f，0.0f，1.0f））；
返回0；
}

我已经在发生错误的代码中进行了注释。通过调试，我可以看到它实际上出现在

vector

的

size（）

函数中，

transData

尚未初始化。我一辈子都搞不明白为什么

transData

还没有初始化！有什么想法吗

谢谢

Gaz.

你在做一个不相关类型之间的C风格演员。这不安全。您需要这样做的事实可能表明您的设计中存在问题，但请尝试替换此项：

vector*transData=（（SimpleVector4*）translation）->SimpleVector4:：getData（）
为此：
vector*transData=dynamic_cast（translation）->getData（）
您正在不相关类型之间执行C样式转换。这不安全。您需要这样做的事实可能表明您的设计中存在问题，但请尝试替换此项：
vector*transData=（（SimpleVector4*）translation）->SimpleVector4:：getData（）
为此：
vector*transData=dynamic_cast（translation）->getData（）
非继承类的强制转换似乎是您的错误
让我们看看你的代码。调用translate函数时，会将SimpleTranslationVector4*
转换为TranslationVector*
。然后将转换后的值再次转换为SimpleVector4*
。但是SimpleVector4
不会继承TranslationVector

此代码也会导致错误
template<class Data>
class SimpleVector4 {
public:
    int a;
};

template<class Data>
class TranslationVector {
};

template<class Data>
class SimpleTranslationVector4 : public SimpleVector4<Data>,
public TranslationVector<Data> {
};

int main() {
    SimpleTranslationVector4<float> A;
    SimpleVector4<float>* b = (SimpleVector4<float>*)&A;
    TranslationVector<float>* c = (TranslationVector<float>*)&A;
    SimpleVector4<float>* d = (SimpleVector4<float>*)c;
    b->a = 1; // ok
    d->a = 1; // error
}

模板
类SimpleVector4{
公众：
INTA；
};
样板
类平移向量{
};
样板
类SimpleTranslationVector4:PublicSimpleVector4，
公共翻译向量{
};
int main（）{
简单转换向量4A；
SimpleVector4*b=（SimpleVector4*）&A；
TranslationVector*c=（TranslationVector*）&A；
SimpleVector4*d=（SimpleVector4*）c；
b->a=1；//确定
d->a=1；//错误
}
非继承类的强制转换似乎是您的错误
让我们看看你的代码。调用translate函数时，会将SimpleTranslationVector4*
转换为TranslationVector*
。然后将转换后的值再次转换为SimpleVector4*
。但是SimpleVector4
不会继承TranslationVector

此代码也会导致错误
template<class Data>
class SimpleVector4 {
public:
    int a;
};

template<class Data>
class TranslationVector {
};

template<class Data>
class SimpleTranslationVector4 : public SimpleVector4<Data>,
public TranslationVector<Data> {
};

int main() {
    SimpleTranslationVector4<float> A;
    SimpleVector4<float>* b = (SimpleVector4<float>*)&A;
    TranslationVector<float>* c = (TranslationVector<float>*)&A;
    SimpleVector4<float>* d = (SimpleVector4<float>*)c;
    b->a = 1; // ok
    d->a = 1; // error
}

模板
类SimpleVector4{
公众：
INTA；
};
样板
类翻译