Question

我有对象

 template <class FLOAT>
 struct Cstruct {
       Struct1<FLOAT> _var1;
       Struct2<FLOAT> _var2;   
       Cstruct(){};
       Cstruct(Struct1 var1,Struct2 var2):_var1(var1),_var2(var2){};
};

FLOAT可以是“double”或“int”。 Struct1和Struct2也使用FLOAT进行模板化。

现在我还宣布了一个全局变量

 Cstruct<double> globalObj_d;Cstruct<int> globalObj_i;

在main（）里面我有

main(){
  // some code
  if double then call func<double>();
  if int    then call func<int>();        

}

并且在templatized func（）里面我有

template<class FLOAT> void func(){
 // some code 
 Struct1<FLOAT> var1;
 Struct2<FLOAT> var2;
 Cstruct<FLOAT> localObj(var1,var2);
 // now i want to assign "localObj" to the global object "globalObj_d"
 if double then 
     globalObj_d = localObj;
 if int then
     globalObj_i = localObj;
}

我收到错误

error C2679: binary '=' : no operator found which takes a right-hand operand of type 'Cstruct<FLOAT>

这是否意味着我必须在Cstruct中明确地写一个“operator =”？我对模板化和全球性对象的理解似乎有点瑕疵。任何帮助都将非常感激。

Answer 1

在这种情况下，您可能需要。请参阅rule of three如果可以，编译器将为您提供一个。您尚未向我们展示Struct1<FLOAT>或Struct2<FLOAT>的定义。如果无法为这些分配生成分配，则无法为CStruct生成分配。

当你在那里时，请避免使用变量名称上的leading underscores。

Answer 2

在你的问题中使用psudocode会让人难以理解。因此，让我尝试将其简化为真正的代码。看来你要做的事情基本上就是这样的：

template <typename VAL>
class Foo
{
public:
  VAL mVal;
};

int main()
{
  Foo <int> global_i;
  Foo <double> global_d;

  Foo <double> local;

  // ...
  if (/*someConditional*/)
    global_i = local;  // <== LINE 1
  else
    global_d = local;  // <== LINE 2
}

这不起作用。请注意，即使LINE1或LINE2中只有一个在运行时执行，它们都是在编译时编译的。第一个尝试将Foo<int>分配给Foo<double>，但这些类型的兼容性不同，因为它们也不兼容：

class Gee
{
};

class Whiz
{
};

int main()
{
  Gee g;
  Whiz w;

  Gee local;
  local = w;  // <<< INCOMPATIBLE TYPES
}

为了完成这项工作，您需要在Foo上提供某种转换运算符，以转换为其他类型的Foo，例如：

template <typename VAL>
class Foo
{
public:
  template <typename OTHER> operator Foo <OTHER> () const 
  {
    Foo <OTHER> ret;
    // ...
    return ret;
   }
};

...或者可能提供两个单独的功能来完成作业;一个用于Foo<int>，另一个用于Foo<double>。

Answer 3

首先：如果类型可能是浮点数或整数，不将其命名为“FLOAT”。您可以使用标准T，或类似Number之类的内容，但绝对可以避免使用FLOAT。

关于真正的问题（或者我对真实问题的猜测）：几乎任何时候你都会根据if (type == X)或switch (type)类代码（至少在C ++中）进行思考，你就是犯了一个根本性的错误 - 你可以可能设法做到这一点，如果你想要非常糟糕，但这不是C ++的工作方式。

在这种情况下，有一种相当简单的方法可以避免它：创建另一个模板。特别是，您可以重载几个函数模板，每个函数模板对应您支持的每个全局模板：

#include <string>
#include <iostream>

int i_global;
double d_global;

template <class T>
void assign(T in) { 
    // this function should never be called.
    assert(false);
}

template<>
void assign<int>(int in) { 
    i_global = in;
}

template<>
void assign<double>(double in) {
    d_global = in;
}

// for the moment, func(input) will just call assign(input):
template <class T>
void func(T input) {
    assign<T>(input);
}

int main(int argc, char **argv) { 
    if (argc != 2) {
        std::cerr << "Usage: trash <number>\n";
        return EXIT_FAILURE;
    }

    std::string in(argv[1]);

    // see if the input contains a decimal point, and act accordingly:
    if (in.find('.') != std::string::npos)
        func(std::stod(in));
    else
        func(std::stoi(in));

    // show the results -- the values of the globals:
    std::cout << "Result:\ndouble: " << d_global << "\nint: " << i_global << "\n";
    return 0;
}

我得到了我希望得到的结果 - 如果我输入类似1.5的内容，它会被分配给double;如果我输入类似123的内容，则会将其分配给int。

在c ++中将局部变量赋值给全局变量

3 个答案: