在 C++ 中将局部变量分配给全局变量

Question

i have object

 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>();        
}

在模板化的 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

在这种情况下，

您可能需要这样做。查看三法则 如果可以，编译器将为您提供一个。您还没有向我们展示Struct1<FLOAT>或Struct2<FLOAT>的定义.如果它无法为这些生成分配，则无法为 CStruct 生成分配。

当您在那里时，请避免变量名称上的前导下划线。

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的东西，它就会被分配给双精度;如果我输入类似123的东西，它就会被分配给int双精度