void frd（ double & ）；
int main()
{
frd( obj ); // 错误：参数必须是const double &
return 0;
}
我想问的是，参数为什么必须是const类型的，double &不行么？
9 个解决方案
#1
int obj;
void frd（ double & ）；
int main()
{
frd( obj ); // 错误：参数必须是const double &
return 0;
}
====================================
你为什么说frd( obj ); // 错误： 参数必须是const double &
另外...obj是一INT类型...这个错误..
下面是我的测试程序:
#include <iostream>
using namespace std;
double obj;
void frd( double &);
int main()
{
frd(obj);
return 0;
}
void frd(double & t)
{
cout<<t<<endl;
}
void frd（ double & ）；
int main()
{
frd( obj ); // 错误：参数必须是const double &
return 0;
}
====================================
你为什么说frd( obj ); // 错误： 参数必须是const double &
另外...obj是一INT类型...这个错误..
下面是我的测试程序:
#include <iostream>
using namespace std;
double obj;
void frd( double &);
int main()
{
frd(obj);
return 0;
}
void frd(double & t)
{
cout<<t<<endl;
}
#2
你frb函数的参数应该是个指针才行~~~
frd( &obj );
这样调用就好了
frd( &obj );
这样调用就好了
#3
还有 obj应该是个double型~~~1楼说的很详细~~
#4
大家没懂我的意思
我看的是参数类型转换这一部分的知识！
书上的解释是“对frd()的调用是错误的。实参类型是int，必须转换成doubl以匹配引用参数的类型。该转换的结果是个临时值。因为这种引用不是const型的，所以临时值不呢个被用来初始化该引用”
我就是不懂为什么必须是const！
我看的是参数类型转换这一部分的知识！
书上的解释是“对frd()的调用是错误的。实参类型是int，必须转换成doubl以匹配引用参数的类型。该转换的结果是个临时值。因为这种引用不是const型的，所以临时值不呢个被用来初始化该引用”
我就是不懂为什么必须是const！
#5
实参类型是int，必须转换成doubl以匹配引用参数的类型。该转换的结果是个临时值，是const类型.因此frd()的参数必须声明为const double&
#6
Internally,a reference maintains the address of the object of which it is an alias.In the case of nonaddressable
value,such as a literal constant,and objects of a different type,to accomplish this the complier must generate a
temporary object that the reference actually address but that the user has no access to.For example,when we write
double dval = 1024;
const int &ri = dval
the complier transforms it into something like this:
int temp = dval;
const int &ri = temp;
If we were to assign ir a new value,we would not change dval but would instead change temp. To the user,it is as
if the change simply did not work(and it doesn't for all the good it does the user)
const reference don't exhibit this problem because they are read-only.Disallowing non-const references to objects
or values requiring temporaries in general seems a better solution than to allow the reference to be defined but
seem not to work.
呵呵，我翻译不好，就照书抄了，大概意思是：
const维护一个变量的地址，而对字面上的常量如：10，12和不同类型的变量，如cont int 要接受一个double型的变量，
它们都是不可以取地址的，那么编译器为了不让用户修改它们，就必须使用const限制，这样要比使用一个引用而这个让它们看起来不能工作。
（最后一句，我不会了。）
这是为什么从int型到double的引用要用const的愿意了，
因为double到int要产生一个临时变量，而个变量的地址是不是修改的，但是用户有要是个引用，一次编译器就要一个const来修饰它，
不知道我翻译对不对，你看上面的原文吧。
#7
obj是int型的，赋给double &，过程是这样的
首先，int会被转换为一个临时变量，即double temp = obj;然后将这个临时变量再赋给frd里面的形参，C++规定临时变量必须用常引用，即const double &
//举个例子
int i;
double &d1 = i; //错了
const double &d2 = i; //正确
#8
很明显，你的函数参数类型不匹配，因此编译器将自动进行类型转换，即从int转换为double，转换得到的临时变量必须是常量引用。（建议阅读C++ Primer Plus，里面讲解的很详细。）
#9
hoho，什么书？中文表达有点混乱，你理解的也就乱了
#1
int obj;
void frd（ double & ）；
int main()
{
frd( obj ); // 错误：参数必须是const double &
return 0;
}
====================================
你为什么说frd( obj ); // 错误： 参数必须是const double &
另外...obj是一INT类型...这个错误..
下面是我的测试程序:
#include <iostream>
using namespace std;
double obj;
void frd( double &);
int main()
{
frd(obj);
return 0;
}
void frd(double & t)
{
cout<<t<<endl;
}
void frd（ double & ）；
int main()
{
frd( obj ); // 错误：参数必须是const double &
return 0;
}
====================================
你为什么说frd( obj ); // 错误： 参数必须是const double &
另外...obj是一INT类型...这个错误..
下面是我的测试程序:
#include <iostream>
using namespace std;
double obj;
void frd( double &);
int main()
{
frd(obj);
return 0;
}
void frd(double & t)
{
cout<<t<<endl;
}
#2
你frb函数的参数应该是个指针才行~~~
frd( &obj );
这样调用就好了
frd( &obj );
这样调用就好了
#3
还有 obj应该是个double型~~~1楼说的很详细~~
#4
大家没懂我的意思
我看的是参数类型转换这一部分的知识！
书上的解释是“对frd()的调用是错误的。实参类型是int，必须转换成doubl以匹配引用参数的类型。该转换的结果是个临时值。因为这种引用不是const型的，所以临时值不呢个被用来初始化该引用”
我就是不懂为什么必须是const！
我看的是参数类型转换这一部分的知识！
书上的解释是“对frd()的调用是错误的。实参类型是int，必须转换成doubl以匹配引用参数的类型。该转换的结果是个临时值。因为这种引用不是const型的，所以临时值不呢个被用来初始化该引用”
我就是不懂为什么必须是const！
#5
实参类型是int，必须转换成doubl以匹配引用参数的类型。该转换的结果是个临时值，是const类型.因此frd()的参数必须声明为const double&
#6
Internally,a reference maintains the address of the object of which it is an alias.In the case of nonaddressable
value,such as a literal constant,and objects of a different type,to accomplish this the complier must generate a
temporary object that the reference actually address but that the user has no access to.For example,when we write
double dval = 1024;
const int &ri = dval
the complier transforms it into something like this:
int temp = dval;
const int &ri = temp;
If we were to assign ir a new value,we would not change dval but would instead change temp. To the user,it is as
if the change simply did not work(and it doesn't for all the good it does the user)
const reference don't exhibit this problem because they are read-only.Disallowing non-const references to objects
or values requiring temporaries in general seems a better solution than to allow the reference to be defined but
seem not to work.
呵呵，我翻译不好，就照书抄了，大概意思是：
const维护一个变量的地址，而对字面上的常量如：10，12和不同类型的变量，如cont int 要接受一个double型的变量，
它们都是不可以取地址的，那么编译器为了不让用户修改它们，就必须使用const限制，这样要比使用一个引用而这个让它们看起来不能工作。
（最后一句，我不会了。）
这是为什么从int型到double的引用要用const的愿意了，
因为double到int要产生一个临时变量，而个变量的地址是不是修改的，但是用户有要是个引用，一次编译器就要一个const来修饰它，
不知道我翻译对不对，你看上面的原文吧。
#7
obj是int型的，赋给double &，过程是这样的
首先，int会被转换为一个临时变量，即double temp = obj;然后将这个临时变量再赋给frd里面的形参，C++规定临时变量必须用常引用，即const double &
//举个例子
int i;
double &d1 = i; //错了
const double &d2 = i; //正确
#8
很明显，你的函数参数类型不匹配，因此编译器将自动进行类型转换，即从int转换为double，转换得到的临时变量必须是常量引用。（建议阅读C++ Primer Plus，里面讲解的很详细。）
#9
hoho，什么书？中文表达有点混乱，你理解的也就乱了