1

由于const int专业化导致的以下错误：

#include <iostream>
using std::cout;
using std::endl;

template <typename T> void g(T val)
{
    cout << "unknown" << endl;
}

template <> void g(int && val)
{
    cout << "int &&" << endl;
}

template <> void g(const int && val)
{
    cout << "const int &&" << endl;
}

template <> void g(int & val)
{
    cout << "int &" << endl;
}

template <> void g(const int & val)
{
    cout << "const int &" << endl;
}

template <> void g(int val)
{
    cout << "int" << endl;
}

template <> void g(const int val)  //redefinition here
{
    cout << "const int" << endl;
}

int main() {}

error: redefinition of 'g'
template <> void g(const int val)
                 ^

为什么是T&andT&&不同于const T&和const T&&但T不不同于const T？

4

2 回答 2

6

因为函数参数的顶级常量是函数的实现细节。例如，以下是有效的：

// Prototype
void foo(int c);

// Implementation
void foo(int const c) { ... }

由于参数是按值传递的，调用者并不真正关心函数是否要修改自己的私有副本。因此，顶级 const-ness 不是函数签名的一部分。

请注意，这只适用于顶级常量！ int和int const在函数原型中是等价的，就像int *和一样int * const。但是int *并int const *没有。

于 2012-10-31T16:07:25.860 回答
0

使用参数时，需要考虑一些事项，A：不通过引用传递参数是创建自己的新变量，B：通过引用传递是使用与参数相同的变量，但名称不同

这很重要，因为：

void doStuff (const int x)
{
    //x is its own constant variable
}

然而

void doStuff (const int& x)
{
    //because x is the same variable that was used when calling this function
    //x can be modified outside of this function, but not inside the function
    //due to the const modifier
}

第二个函数上的 const 修饰符允许您执行以下操作：

int main ()
{
    const int x = 10;
    doStuff(x)
}

引用用于修改另一个函数中的变量并节省堆栈上的内存，这可以节省内存，因为它使用指针而不是新创建的变量，因此任何大于 int 的东西都会通过使用引用来节省内存，即使你没有在函数中修改它

现在，如果我是正确的，则不应在参数中使用 && 运算符，因为这是一个布尔运算符并且不会修改参数类型。它只能在条件下使用，但在编译时不会产生语法错误（编译器认为它是类型 [type] & 的引用），但这对变量的使用方式没有任何影响，除了计算机处理时间稍长

于 2012-10-31T20:01:38.817 回答