C++ c++；模板铸造

我对如何转换模板有点迷茫。我有一个函数foo，它接受类型为

ParamVector*

的参数。我想传入一个

ParamVector*

，但我不知道如何为我的

ParamVector

类重载casting操作符，而Google也帮不了我那么多。有没有人举过这样的例子？谢谢

编辑：添加一些代码，对不起，我是个白痴，没有很好地表达原始问题

template<class T> class ParamVector 
{
public:
    vector <T> gnome;
    vector <T> data_params;
}

template<class T> class ParamVectorConsumer
{
 public:
 ParamVector<T> test;
}

ParamVector<float> tester;
ParamVectorConsumer<double> cons;
cons.ParamVector = tester

模板类参数向量
{
公众：
向量侏儒；
矢量数据参数；
}
模板类ParamVectorConsumer
{
公众：
副载体试验；
}
参数向量测试仪；
准矢量；
cons.ParamVector=测试仪

将无法编译。我想知道如何编写它，以便我可以将tester的float版本转换为ParamVector双精度。谢谢

---

编辑2：铸造是个错误的词。我不介意写额外的代码，我只需要知道如何让编译器接受它，这样我就可以写一些转换代码。

你会迷失，因为你做不到-这两种类型完全不同。每当你在代码中遇到强制转换的需要时，你应该仔细检查你的代码和设计——一个或两个都可能是错误的。

你不能用直接强制转换，因为double和float的大小完全不同。双精度是64位，而浮点数是32位。强制从一个指针上投射的指针

ParamVector<float>

如果强制将其解释为32位值的数组，则无法正确解释。你可能得到，也可能得不到

0 => abcdabcd
1 => 12341234
2 => abcdabcd
3 => abcdabcd

---

或者可以将其切换为先使用12341234，或者根据单词排序的方式选择一些不熟悉的词。

我不确定，但也许您需要这样的词：

template< typename TypeT >
struct ParamVector
{
    template < typename NewTypeT >
    operator ParamVector< NewTypeT >()
    {
        ParamVector< NewTypeT > result;
        // do some converion things
        return result;
    }

    template< typename NewTypeT >
    ParamVector( const ParamVector< NewTypeT > &rhs )
    {
        // convert
    }

    template < typename NewTypeT >
    ParamVector& operator=( const ParamVector< NewTypeT > &rhs )
    {
        // do some conversion thigns
        return *this;
    }


};
ParamVector< double > d1;
ParamVector< float > f1;
f1 = d1;

模板
结构参数向量
{
模板
运算符ParamVector（）
{
参数向量结果；
//做一些对流的事情
返回结果；
}
模板
参数向量（常数参数向量&rhs）
{
//皈依
}
模板
参数向量和运算符=（常量参数向量&rhs）
{
//做一些转换的事情
归还*这个；
}
};
参数向量d1；
参数向量f1；
f1=d1；

您可以选择use conversion operator或operator=-我在示例中已经提供了这两种运算符。

您在标题中提到了“模板转换”，因此我假设

ParamVector

是一种模板类型。这意味着

foo

也可以被模板化，这将解决您的问题

template <typename T>
void foo(ParamVector<T> const& data)
{
}

模板
void foo（参数向量常量和数据）
{
}

不能像这样强制转换模板，因为类型是不相关的

但是，您可以添加转换函数，例如：

（你的代码不是很完整，所以我也可以发布完整的代码。希望你能理解。）

模板类ParamVectorConsumer
{
公众：
副载体试验；
模板ParamVectorConsumer转换（）
{
副向量；
ret=此->。。。
}

好吧，你不能。每个不同的实际模板参数都会生成一个全新的类，它与任何其他类都没有*关系继承关系，具有不同的实际参数，由该模板生成

没有关系。好吧，除了每个都提供相同的接口，以便在模板中可以处理相同的接口

但是静态类型和动态类型都没有任何关系

让我回到这里，解释一下

当我声明一个指向类类型的指针时，比如

Foo fp*;

fp具有我们称之为静态类型的指向Foo的指针。如果类Bar是Foo的子类，并且我将fp指向新的条：

fp = new Bar1();

然后我们说fp指向的对象具有动态类型的条

如果Bar2也公开派生自Foo，我可以这样做：

fp = new Bar2();

甚至不知道fp指向什么，我可以调用Foo中声明的虚拟方法，让编译器确保在指向的动态类型中定义的方法就是调用的方法

对于

模板struct Baz{void doSomething（）；}；

Baz

和

Baz

是两种完全不同的类类型，没有任何关系

唯一的“关系”是我可以对两者调用doSomething（），但是由于静态类型没有关系，如果我有一个

Baz bi*

，我就不能将它指向一个

Baz

。即使使用cast也不行。编译器无法将对Baz dosothing方法的调用“转换”为对Baz:：doSomething（）的调用方法。这是因为没有“Baz方法”，没有Baz，有ony

Baz

和

Baz

，还有

Baz

，但没有共同的父级。Baz不是一个类，Baz是一个模板，一组关于如何创建类的说明，当且仅当我们有一个绑定到实际类型（或常量）的T参数时

现在我有一种方法可以将这些Baze视为相同的对象：在模板中，它们呈现相同的接口，并且编译器，如果知道我们真正处理的是哪种类型的Baz，可以对该方法进行静态调用（或静态访问成员变量）

但模板不是代码，模板是元代码，是如何合成类的指令。模板中的“调用”不是调用，而是如何编写代码以进行调用的指令

所以。这是冗长而混乱的。在模板定义之外，ParamVector和aParamVector之间没有关系。所以你的赋值不能工作

嗯，差不多了

实际上，通过部分应用模板，您可以编写一个模板函数，该函数给出了如何将

Paramvector

转换为

Paramvector

的“配方”

Foo fp*;

fp = new Bar1();

fp = new Bar2();

template<class T> class ParamVector 
{
public:
    vector <T> gnome;
    vector <T> data_params;

    ParamVector()
    {
    }
    template <class T2> ParamVector(const ParamVector<T2> &source)
    {
        gnome.reserve(source.gnome.size());
        copy(source.gnome.begin(), source.gnome.end(), gnome.begin());
        data_params.reserve(source.data_params.size());
        copy(source.data_params.begin(), source.data_params.end(), data_params.begin());
    }
};