不是很明白的 返回值_c语言吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：273,311贴子：
不是很明白的 返回值收藏
书上说在主调函数中对被调函数说明是为了使编译系统知道被调函数的返回值的类型，那么那些无返回值的被调函数为什么还要进行说明啊？
好奇怪啊~
快试试吧，可以对自己使用挽尊卡咯~◆◆
主调函数中对被调函数说明是为了使编译系统知道被调函数的返回值的类型,这句话有问题，声明是为了让主函数知道你所声明的函数是存在的，因此如果你在主函数之前就已经写好一个函数，那么你就不必对他声明。所以就算无返回值，只要你在主函数重要引用它，（除非这个函数写在主函数前）你一定要对它声明
我的那句话真的是从书上抄来的，不骗人的哦~
不信也可以去翻翻看，谢乐军的，冶金出版社的、
lz你应该这么想，无返回值也是返回值的一种情况。
void&func(int&x)
void&也是一种资料型态
楼主，书也有可能是错的。如果你这句话是从书上原原本本抄来的，那书肯定就是错的。要养成良好的声明习惯。
除void外
还有void*&...
神奇的void
快试试吧，可以对自己使用挽尊卡咯~◆◆
艾。。Void无返回值类型。。也是一种类型。。不要以为他没有返回值。。就不是一种类型了
语法上规定没有返回值的函数调用表达式有一个void类型的值，这样的话任何表达式都有值，就没有特殊情况，编译器的语法解析容易一些，然后语义上规定void类型的值不能运算，从而兼顾了语法上的一致和语义上的不矛盾。
void*&是一个很奇妙的东西
(int(*)(const&void*,const&void*)pf)
那个不是没返回值，应该叫做“空返回值”，另外void*和int*、char*一样都是指针类型，不是什么“好玩的东西”。
不是好玩
是奇妙
当一个函数被调用时，编译器如果无法看到它的任何声明，那么它就假定函数返回一个整型值，对于那些返回值不是整型的函数，在调用之前对它们进行声明是非常重要的，可以避免由不可预测的类型转换而导致的错误，
对于那些没有原型的函数，传递给函数的参数将进行参数提升，char,short实参被转换为int,flaot-&double.
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或在C++中，若定义一个函数的返回类型为void，以下叙述正确的是_百度知道
在C++中，若定义一个函数的返回类型为void，以下叙述正确的是
：用语句调用函数
B：没有返回值
D：用表达式调用函数
:规则一 如果函数没有返回值;原因就是不知道具体类型的指针就不知道它所占用的内
存是多少.g;ANSI标准，void *可以指向任何类型的数据, int c:void * memset ( void * buffer,所以A和C都是正确的.，那么应声明为void类型.;函数默认的返回值是int；
（2） 对函数参数的限定;/
&#47.，那么应声明其参数为void *, size_t num )--&--&gt.;&#47.;给出一个函数原形，void *则为“无类型指针”:e...,这点要注意规则二 如果函数无参数：
（1） 对函数返回的限定;&#47,那多进行算法操作就可能会引起很严重的错误规则四 如果函数的参数可以是任意类型指针.;&#47.void就是表示没有返回值;
/int Function(void)表示这个函数不接受任何参数--&
&#47.不允许对void指针进行算法操作--&gt.A和C是正确的.Trust me,那么应声明其参数为void.void的字面意思是“无类型”。关于void的使用。void真正发挥的作用在于;
/内存操作函数它
能够接受任何类型的指针规则五 void不能代表一个真实的变量.;Function(1)就是错误的规则三 小心使用void指针类型,void函数用语句是肯定可以调用的;错误所以就以上来理解;&#47A和C都是正确的
其他类似问题
函数的相关知识
按默认排序
其他1条回答
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁第六章函数熟练掌握函数的定义`调用`返回值的方法及参数传递方式—文档、资料、论..
扫扫二维码，随身浏览文档
手机或平板扫扫即可继续访问
第六章函数熟练掌握函数的定义`调用`返回值的方法及参数传递方式
举报该文档为侵权文档。
举报该文档含有违规或不良信息。
反馈该文档无法正常浏览。
举报该文档为重复文档。
推荐理由：
将文档分享至：
分享完整地址
文档地址：
粘贴到BBS或博客
flash地址：
支持嵌入FLASH地址的网站使用
html代码：
&embed src='/DocinViewer-4.swf' width='100%' height='600' type=application/x-shockwave-flash ALLOWFULLSCREEN='true' ALLOWSCRIPTACCESS='always'&&/embed&
450px*300px480px*400px650px*490px
支持嵌入HTML代码的网站使用
您的内容已经提交成功
您所提交的内容需要审核后才能发布，请您等待！
3秒自动关闭窗口2100人阅读
看到const 关键字，C++程序员首先想到的可能是const 常量。这可不是良好的条件反射。如果只知道用const 定义常量，那么相当于把火药仅用于制作鞭炮。const 更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。
const 是constant 的缩写，“恒定不变”的意思。被const 修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Use const whenever you need”。
1.用const 修饰函数的参数
如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const 修饰，否则该参数将失去输出功能。const 只能修饰输入参数：
如果输入参数采用“指针传递”，那么加const 修饰可以防止意外地改动该指针，起到保护作用。
例如StringCopy 函数：
void StringCopy(char *strDestination, const char *strSource);
其中strSource 是输入参数，strDestination 是输出参数。给strSource 加上const修饰后，如果函数体内的语句试图改动strSource 的内容，编译器将指出错误。
如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const 修饰。
例如不要将函数void Func1(int x) 写成void Func1(const int x)。同理不要将函数void Func2(A a) 写成void Func2(const A a)。其中A 为用户自定义的数据类型。
对于非内部数据类型的参数而言，象void Func(A a) 这样声明的函数注定效率比较底。因为函数体内将产生A 类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。
为了提高效率，可以将函数声明改为void Func(A &a)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数void Func(A &a) 存在一个缺点：
“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为void Func(const A &a)。
以此类推，是否应将void Func(int x) 改写为void Func(const int &x)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。
问题是如此的缠绵，我只好将“const &”修饰输入参数的用法总结一下。
对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const 引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。
&对于内部数据类型的输入参数，不要将“值传递”的方式改为“const 引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。
2 用const 修饰函数的返回值
如果给以“指针传递”方式的函数返回值加const 修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const 修饰的同类型指针。
例如函数：
const char * GetString(void);
如下语句将出现编译错误：
char *str = GetString();
正确的用法是
const char *str = GetString();
如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const 修饰没有任何价值。
例如不要把函数int GetInt(void) 写成const int GetInt(void)。
同理不要把函数A GetA(void) 写成const A GetA(void)，其中A 为用户自定义的数据类型。
如果返回值不是内部数据类型，将函数A GetA(void) 改写为const A & GetA(void)的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。
函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。
A & operate = (const A &other); // 赋值函数
A a, b, // a, b, c 为A 的对象
a = b = // 正常的链式赋值
(a = b) = // 不正常的链式赋值，但合法
如果将赋值函数的返回值加const 修饰，那么该返回值的内容不允许被改动。上例中，语句 a = b = c 仍然正确，但是语句 (a = b) = c 则是非法的。
3 const 成员函数(const的作用：说明其不会修改数据成员)
任何不会修改数据成员的函数都应该声明为const 类型。如果在编写const 成员函数时，不慎修改了数据成员，或者调用了其它非const 成员函数，编译器将指出错误，这无疑会提高程序的健壮性。以下程序中，类stack 的成员函数GetCount 仅用于计数，从逻辑上讲GetCount 应当为const 函数。编译器将指出GetCount
函数中的错误。
class Stack
void Push(int elem);
int Pop(void);
int GetCount(void) // const 成员函数
int m_data[100];
int Stack::GetCount(void) const
++m_ // 编译错误，企图修改数据成员m_num
Pop(); // 编译错误，企图调用非const 函数
const 成员函数的声明看起来怪怪的：const 关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。
关于Const函数的几点规则：
a. const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.
b. const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.
c. const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.
e. 然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的。
//*********************************************************
看C++教材的时候，对于const function以为有了很正确的理解，但到使用时才知道，实践出真知！
const 函数只能调用 const 函数，即使某个函数本质上没有修改任何数据，但没有声明为const，也是不能被const函数调用的。
对于这样的const function，关键词const到底影响了什么？下面用例子来说明。
class my {
string& operator[](const string& s) const
{ return table[s]; }
上述重载的下标运算函数能否通过编译呢？不能（在mingw32 gcc3.4上）通过。给出了如下的错误提示：
passing `const std::map, std::allocator & &'
as `this' argument of `_Tp& std::map&_Key, _Tp, _Compare, _Alloc&::operator[](const _Key&) [with _Key = std::string, _Tp = std::string, _Compare = std::less, _Alloc = std::allocator &]' discards qualifiers
错误原因就在于，当本重载函数声明为const后，就只能调用其他的同样也声明为const的函数；而table[s]实际上调用的是map的下标重载运算函数，该函数并没有声明为const。所以去掉本函数的const声明，就可以顺利通过编译了。
下面再用一个小例子验证一下吧。
A(int n) { num = }
void incr() { num += 5; }
void disp() const
{ cout && }
int times(int m)
{ return num * }
int f() const
incr();//passing `const A' as `this' argument of `void A::incr()' discards qualifiers
disp();// ok
times(2);//passing `const A' as `this' argument of `int A::times(int)' discards qualifiers
int main(int argc, char *argv[])
system(&PAUSE&);
return EXIT_SUCCESS;
const 函数只能调用 const 函数，即使某个函数本质上没有修改任何数据，但没有声明为const，也是不能被const函数调用的。
//********************************************************************
为何const引用不能调用自己的非const方法和其它？
我在实现自定义的DateTime类时有这个问题：
bool DateTime::earlier(const DateTime &dt){
if(!isvalid())
if(!dt.isvalid())
isvalid是DateTime自己的方法。但第二个判断会出错，提示 The non-const member function &DateTime::isvalid()& is called for &const DateTime&
为何这里会报这个错误有点不大明白。难道这种传进本类引用的方法就不能使用const参数，或只能调用const方法？
另外还有，我在重载＝＝时也有问题：
inline bool operator ==(const DateTime& );
它的实现是：
inline bool operator ==(const DateTime& _dt){
return !earlier(_dt) && !_dt.earlier(*this);
这就报参数数量不符(Wrong number of parameters for &operator&=&)。方法定义的格式我是参照c++ primar里的，作者在定义时就只写参数类型没写形参名称（写了一样报错）。不知错在哪里？之前写的+,-重载都不报这个错。
---但第二个判断会出错，提示 The non-const member function &DateTime::isvalid()& is called for &const DateTime&
每个非static非const成员函数都有一个隐含的this指针，是非const型的，不能接受const型实参；在你的函数里，dt是const DateTime &型的，dt.isvalid()相当于将const对象传给非const的this指针，所以出错。
如果isvalid不改变对象状态，可以将earlier成员函数定义为const型。
如果用const来修饰函数，那么函数一定是类的成员函数。
const 类型的成员函数不能返回非const类型的引用
这句话的意思是如果你的成员函数是const类型的，并且要求返回值是类的非cosnt或者非mutable成员变量，返回类型是引用，那么这是错误的。
class Test
int & GetValue()
int &Test::GetValue() const
//value此时具有const属性，与返回值类型int &的非const属性不匹配
这样的代码在vs2003中提示的错误：error C2440: “return” : 无法从“const int”转换为“int &”。
在const函数中传递this的时候把this变成了const T* const this（个人理解）,所以一个非const的引用指向一个const类型的变量，就会error。
可以这样改，
1.把int value 改成mutable int value. mutable修饰的变量使之在const函数中可以被改变的。
2.return value 改成。 return const_cast(value)。const_cast去掉了const性质。
3.把函数写成const int &Test::GetValue() const ,.这样做的目的是使引用的变量也是const类型的，就相当于const int & b 。
4.把引用去掉，写成返回值类型的。
5.把函数后面的const去掉。
6.返回值不是类的成员变量。
int &Test::GetValue() const
int temp =
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：71563次
积分：1022
积分：1022
排名：第19489名
原创：21篇
转载：47篇
评论：21条
(4)(1)(1)(3)(4)(3)(4)(8)(4)(2)(3)(3)(2)(1)(1)(8)(5)(3)(1)(1)(1)(5)----> 那么函数返回值
那么函数返回值
&&&&&&&&&&&&
&&&&const成员函数看到const关键字，C++程序员首先想到的可能是const常量。这可不是良好的条件反射。如果只知道用const定义常量，那么相当于把火药仅用于制作鞭炮。const更大的魅力是它可以修饰函数的参数、返回值，甚至函数的定义体。const是constant的缩写，“恒定不变”的意思。被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。所以很多C++程序设计书籍建议：“Useconstwheneveryouneed”。1.用const修饰函数的参数如果参数作输出用，不论它是什么数据类型，也不论它采用“指针传递”还是“引用传递”，都不能加const修饰，否则该参数将失去输出功能。const只能修饰输入参数：如果输入参数采用“指针传递”，那么加const修饰可以防止意外地改动该指针，起到保护作用。例如StringCopy函数：voidStringCopy(char*strDestination,constchar*strSource);其中strSource是输入参数，strDestination是输出参数。strSource加上const给修饰后，如果函数体内的语句试图改动strSource的内容，编译器将指出错误。如果输入参数采用“值传递”，由于函数将自动产生临时变量用于复制该参数，该输入参数本来就无需保护，所以不要加const修饰。例如不要将函数voidFunc1(intx)写成voidFunc1(constintx)。同理不要将函数voidFunc2(Aa)写成voidFunc2(constAa)。其中A为用户自定义的数据类型。对于非内部数据类型的参数而言，象voidFunc(Aa)这样声明的函数注定效率比较底。因为函数体内将产生A类型的临时对象用于复制参数a，而临时对象的构造、复制、析构过程都将消耗时间。为了提高效率，可以将函数声明改为voidFunc(Aa)，因为“引用传递”仅借用一下参数的别名而已，不需要产生临时对象。但是函数voidFunc(Aa)存在一个缺点：“引用传递”有可能改变参数a，这是我们不期望的。解决这个问题很容易，加const修饰即可，因此函数最终成为voidFunc(constAa)。以此类推，是否应将voidFunc(intx)改写为voidFunc(constintx)，以便提高效率？完全没有必要，因为内部数据类型的参数不存在构造、析构的过程，而复制也非常快，“值传递”和“引用传递”的效率几乎相当。问题是如此的缠绵，我只好将“const”修饰输入参数的用法总结一下。&&&&&&&&对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将voidFunc(Aa)改为voidFunc(constAa)。&&&&&&&&对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如voidFunc(intx)不应该改为voidFunc(constintx)。2用const修饰函数的返回值如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。例如函数constchar*GetString(void);如下语句将出现编译错误：char*str=GetString();正确的用法是constchar*str=GetString();如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。例如不要把函数intGetInt(void)写成constintGetInt(void)。同理不要把函数AGetA(void)写成constAGetA(void)，其中A为用户自定义的数据类型。如果返回值不是内部数据类型，将函数AGetA(void)改写为constAGetA(void)的确能提高效率。但此时千万千万要小心，一定要搞清楚函数究竟是想返回一个对象的“拷贝”还是仅返回“别名”就可以了，否则程序会出错。函数返回值采用“引用传递”的场合并不多，这种方式一般只出现在类的赋值函数中，目的是为了实现链式表达。例如：classA{Aoperate=(constAother);//赋值函数};Aa,b,c;//a,b,c为A的对象a=b=c;//正常的链式赋值(a=b)=c;//不正常的链式赋值，但合法如果将赋值函数的返回值加const修饰，那么该返回值的内容不允许被改动。上例中，语句a=b=c仍然正确，但是语句(a=b)=c则是非法的。3const成员函数(const的作用：说明其不会修改数据成员)任何不会修改数据成员的函数都应该声明为const类型。如果在编写const成员函数时，不慎修改了数据成员，或者调用了其它非const成员函数，编译器将指出错误，这无疑会提高程序的健壮性。以下程序中，类stack的成员函数GetCount仅用于计数，从逻辑上讲GetCount应当为const函数。编译器将指出GetCount函数中的错误。classStack{public:voidPush(intelem);&&&&&&&&intPop(void);intGetCount(void)//const成员函数private:intm_intm_data[100];};intStack::GetCount(void)const{++m_//编译错误，企图修改数据成员m_numPop();//编译错误，企图调用非const函数returnm_}const成员函数的声明看起来怪怪的：const关键字只能放在函数声明的尾部，大概是因为其它地方都已经被占用了。关于Const函数的几点规则：a.const对象只能访问const成员函数,而非const对象可以访问任意的成员函数,包括const成员函数.b.const对象的成员是不可修改的,然而const对象通过指针维护的对象却是可以修改的.c.const成员函数不可以修改对象的数据,不管对象是否具有const性质.它在编译时,以是否修改成员数据为依据,进行检查.e.然而加上mutable修饰符的数据成员,对于任何情况下通过任何手段都可修改,自然此时的const成员函数是可以修改它的&&&&&&&&//*********************************************************看C++教材的时候，对于constfunction以为有了很正确的理解，但到使用时才知道，实践出真知！const函数只能调用const函数，即使某个函数本质上没有修改任何数据，但没有声明为const，也是不能被const函数调用的。对于这样的constfunction，关键词const到底影响了什么？下面用例子来说明
。//classmy{public://...stringoperator[](conststrings)const{returntable[s];}private:mapstring,};上述重载的下标运算函数能否通过编译呢？不能（在mingw32gcc3.4上）通过。给出了如下的错误提示：&&&&&&&&passing`conststd::mapstd::string,std::string,std::lessstd::string,std::allocatorstd::pairconststd::string,std::stringas`thisargumentof`_Tpstd::map_Key,_Tp,_Compare,_Alloc::operator[](const_Key)[with_Key=std::string,_Tp=std::string,_Compare=std::lessstd::string,_Alloc=std::allocatorstd::pairconststd::string,std::string]discardsqualifiers错误原因就在于，当本重载函数声明为const后，就只能调用其他的同样也声明为const的函数；而table[s]实际上调用的是map的下标重载运算函数，该函数并没有声明为const。所以去掉本函数的const声明，就可以顺利通过编译了。下面再用一个小例子验证一下吧。#includecstdlib#includeiostrclassA{public:A(intn){num=n;}voidincr(){num+=5;}voiddisp()const{}inttimes(intm){returnnum*m;}intf()const{incr();//passing`constAas`thisargumentof`voidA::incr()discardsqualifiersdisp();//oktimes(2);//passing`constAas`thisargumentof`intA::times(int)discard}private:};intmain(intargc,char*argv[]){Aa(5);a.f();system(PAUSE);returnEXIT_SUCCESS;}&&&&&&&&const函数只能调用const函数，即使某个函数本质上没有修改任何数据，但没有声明为const，也是不能被const函数调用的。&&&&&&&&///********************************************************************为何const引用不能调用自己的非const方法和其它？&&&&&&&&我在实现自定义的DateTime类时有这个问题：boolDateTime::earlier(constDateTimedt){if(!isvalid())if(!dt.isvalid())isvalid是DateTime自己的方法。但第二个判断会出错，提示Thenon-constmemberfunctionDateTime::isvalid()iscalledforconstDateTime为何这里会报这个错误有点不大明白。难道这种传进本类引用的方法就不能使用const参数，或只能调用const方法？另外还有，我在重载＝＝时也有问题：inlinebooloperator==(constDateTime);它的实现是：inlinebooloperator==(constDateTime_dt){return!earlier(_dt)!_dt.earlier(*this);}这就报参数数量不符(Wrongnumberofparametersforoperator=)。方法定义的格式我是参照c++primar里的，作者在定义时就只写参数类型没写形参名称（写了一样报错）。不知错在哪里？之前写的+,-重载都不报这个错。&&&&&&&&---但第二个判断会出错，提示Thenon-constmemberfunctionDateTime::isvalid()iscalledforconstDateTime每个非static非const成员函数都有一个隐含的this指针，是非const型的，不能接受const型实参；在你的函数里，dt是constDateTime型的，dt.isvalid()相当于将const对象传给非const的this指针，所以出错。如果isvalid不改变对象状态，可以将earlier成员函数定义为const型。如果用const来修饰函数，那么函数一定是类的成员函数。const类型的成员函数不能返回非const类型的引用这句话的意思是如果你的成员函数是const类型的，并且要求返回值是类的非cosnt或者非mutable成员变量，返回类型是引用，那么这是错误的。&&&&&&&&classTest{public:intGetValue()private:};intTest::GetValue()const{//value此时具有const属性，与返回值类型int的非const属性不匹配}这样的代码在vs2003中提示的错误：errorC2440:“return”:无法从“constint”转换为“int”。在const函数中传递this的时候把this变成了constT*constthis（个人理解）,所以一个非const的引用指向一个const类型的变量，就会error。可以这样改，1.把intvalue改成mutableintvalue.mutable修饰的变量使之在const函数中可以被改变的。2.returnvalue改成。returnconst_castint(value)。const_cast去掉了const性质。3.把函数写成constintTest::GetValue()const,.这样做的目的是使引用的变量也是const类型的，就相当于constintb。4.把引用去掉，写成返回值类型的。5.把函数后面的const去掉。6.返回值不是类的成员变量。intTest::GetValue()const{inttemp=}&&&&&&&&
分享给好友::
All Rights Reserved 图宝贝
本站声明：本站所转载之内容，无任何商业意图，如本网站转载稿件涉及版权、著作权等问题，请您来函与本站管理员取得联系,友情链接请加QQ,要求PR 或者 BR >=2（联系方式：QQ ）