C++ 模板复制构造函数

想象一下下面的例子：

#include <iostream>
#include <vector>

struct Base
{
    virtual void foo() = 0;
};

struct A : public Base
{
    void foo() override {};
};

struct B : public Base
{
    void foo() override {};
};

template <typename T>
struct C
{
    struct Element
    {
        int x, y, z;

        bool operator==(const Element& e)
        {
            if (x != e.x) return false;
            if (y != e.y) return false;
            if (z != e.z) return false;
            return true;
        }
    };

    Base* p;
    std::vector<Element> v;

    C()
    {
        p = new T();
    }

    void add(int x, int y, int z)
    {
        Element e;
        e.x = x;
        e.y = y;
        e.z = z;
        v.push_back(e);
    }

    void remove(int x, int y, int z)
    {
        Element e;
        e.x = x;
        e.y = y;
        e.z = z;
        std::vector<Element>::iterator it = std::find(v.begin(), v.end(), e);
        if (p != v.end()) v.erase(p);
    }

    void print()
    {
        for (Element e : v) std::cout << e.x << " " << e.y << " " << e.z << std::endl;
    }
};

int main()
{
    C<A> a;

    a.add(1, 2, 3);
    a.add(4, 5, 6);
    a.add(7, 8, 9);

    a.remove(4, 5, 6);

    a.print();

    return 0;
}

#包括
#包括
结构基
{
虚拟void foo（）=0；
};
结构A：公共基础
{
void foo（）重写{}；
};
结构B：公共基础
{
void foo（）重写{}；
};
模板
结构C
{
结构元素
{
int x，y，z；
布尔运算符==（常量元素&e）
{
如果（x！=e.x）返回false；
如果（y！=e.y）返回false；
如果（z！=e.z）返回false；
返回true；
}
};
碱基*p；
std：：向量v；
C（）
{
p=新的T（）；
}
无效添加（整数x，整数y，整数z）
{
元素e；
e、 x=x；
e、 y=y；
e、 z=z；
v、 推回（e）；
}
无效删除（整数x，整数y，整数z）
{
元素e；
e、 x=x；
e、 y=y；
e、 z=z；
std:：vector:：iterator it=std:：find（v.begin（），v.end（），e）；
如果（p！=v.end（））v.erase（p）；
}
作废打印（）
{
对于（元素e:v）std:：cout
这是两种完全不同的类型

v
是
std:：vector

c.v
是
std:：vector

给定不同的
T
和
U
类型，
C
和
C
是完全不同的类型，彼此没有关系

C:：Element
和
C:：Element
也是完全不同的类型。每种类型的
std:：vector
也是如此

C:：Element
和
C:：Element
可能具有相同的类名。它们可能具有完全相同的类成员。但它们是两个独立的类型，就像
类A
与
类B
不同一样。
问题不在于模板复制构造函数本身。问题在于复制构造函数试图将一种类型分配给彼此

您需要做的是删除内部类
元素
。它不依赖于模板参数。将其作为一个独立的顶级类。然后，
C
和
C
都将有一个类成员
v
，该类成员是相同类型的向量，并且可以相互分配。
您可能需要添加一个
virtualbase*clone（）const=0；
到您的基类，并在派生类中重写它以进行实际克隆，然后调用它来复制
p
+1作为开始重点。当我进入模板元编程领域时，理解someClass和someClass是完全不同的类型花了一些时间。感谢您的回复，移动t元素类有效。令我惊讶的是，尽管两个向量中的元素完全相同，但这两个向量被认为是不同的类型。
class A{class Element{int x；}；class B{class Element{int x；}
--
A:：Element
和
B:：Element
是两个不同的类，它们彼此无关。是的，当你这样说的时候，它很有意义。我更多地考虑了
Element
类中的内部字节结构，因此我认为在逻辑上可以分配特定的AIN组字节到另一组相同的字节，即使它们没有共享相同的名称。这只是一个C++语法限制，还是在C/CUSTED中禁用？
int main()
{
    C<A> a;

    a.add(1, 2, 3);
    a.add(4, 5, 6);
    a.add(7, 8, 9);

    a.remove(4, 5, 6);

    a.print();

    C<B> b(a); // <----- This should be possible.

    return 0;
}

template <typename U>
C(const C<U>& c)
{
    p = new U(*c.p);
    v = c.v;
}

v = c.v;