C++ primer读书笔记
C++primer读书笔记
标题:重载函数再论
重载函数是C++提出来的概念,但是在C中却未必没有。比如“1+3”和“1.0+3.0”,虽然都是加法,做的却不是同的操作:编译器要因操作数的不同而调用不同的加法操作。只是C语言中除了内部类型变量可以参与运算以外,没有“类”这么高深的概念。“结构体”也只是内存数据的组织方法,而不涉及对整个结构体的处理。所以,在C语言时代编译器明明做了类似于重载的事情,却可以像雷锋一样“做好事不留名”。
C++发展出了类,并且赋予了“类”很高的期望,类的对象也能像内置类型对象一样参与一切运算。那么,就拿加法运算来说,编译器如何知道对某类对象的加法该调用哪一个详细的操作代码?于是,即使不出现普通函数的重载,至少运算符是要重载的。
林锐博士在《高质量C++/C编程指南》中为重载函数的必要性提了另一个理由:类的构造函数名称必须与类名相同,而类却经常要定义多个不同的构造函数。那就只好重载了。
对于普通程序员来说,我们完全可以不用考虑得这么深。重载函数给我们至少还带来了另一个好处:不用记忆多个不同的函数名了,也不用为了给函数起名而绞尽脑汁了。不过本书还给出了一个建议:并不是任何时候都有必要重载函数的,有的时候不同的函数名可以直观地带来好多信息,滥用重载只是牺牲了名称中的信息。
标题::重载函数的概念
引用:出现在相同作用域中的两个(可以是两个以上——偷猫注)函数,如果具有相同的名字而形参表不同,则称为重载函数。
本节开头第一句话就给出了重载函数的定义:重载函数必须符合两个条件:一是出现在相同的作用域中、二是函数名字相同而形参表不同。
其中第一个条件一般人往往是不去想的,其实函数名相同而作用域不同的函数大大存在,比如在MFC中就有。它们是完全不相干的函数。
第二个条件还可以详说一下:函数名字相同当然不在话下,这是函数被称为“重载”的根源。之于形参表不同,可能表现在形参个数不同、可能表现在形参类型不同、还可能表现在形参顺序不同。
如果要扩展开来说,还可以举出许多不是重载函数的情况。
一、如果既在同一作用域下、名称也相同、形参表也相同,则后者被视为前者的重复声明。——函数可以重复声明,因为函数的声明并不产生目标代码,但是函数的定义不允许重复出现。
二、如果既在同一作用域下、名称也相同、形参表也相同,但是返回值不同,则后者被视为错误的声明。函数不可以只凭返回值来区分,因为调用函数的时候只凭名称和形参来选择函数,而不凭返回值。再究其原因,一是因为函数的返回值可以被丢弃;二来即使不丢弃,将返回值赋予另一个变量之前没必要检查我需要什么样的返回值,而能否赋值也与函数本身无关。
三、有些时候看起来形参表不同,实际上是完全相同的,书本第229页讲了四组这样的例子:
Record lookup(const Account&acct);
Record lookup(const Account&);//区别在于有没有给形参命名
typedef Phone Telno;
Record lookup(const Phone&);
Record lookup(const Telno&);//只是给类型取了个别名
Record lookup(const Phone&,const Name&);
Record lookup(const Phone&,const Name&="");//区别在于给形参提供了默认值
Record lookup(Phone);
Record lookup(const Phone);//区别在于是否const
其中第三组可能会让人产生函数的形参个数不同的假像,其实可缺省的形参并没有减少形参的个数。第四组有点不容易搞清:因为有的时候可以凭是否const来重载,比如引用传递和指针传递。
标题::文件的组织
一个程序往往由多个源文件组成,这些代码究竟应该放在哪个源文件里、哪些代码可以放在同一个源文件里、哪些代码必需分开放。这是一个管理层面的问题。
说它是管理层面的问题,是因为这些代码的组织往往没有惟一的准则。但是它们还是有一定的规律的。
首先,软件的维护是一个复杂的系统工程。代码的组织应该有利于维护。应该尽量把直接相关的内容放在同一文件、不相关的内容放在不同的文件里。如果这些代码还有亲和疏,那就要分不同的文件夹来存放了。
其次,软件的代码是一个严格的组织体系。不同的内容之间可能是并列的,也可能有必要的先后关系。于是在“#include”的时候要注意顺序。
最后,也是最重要的一点,有些代码在同一工程中可以重用(或必须重用),有些代码在同一个工程中只能出现一次。可以重用的有类的声明、函数的声明、变量的声明等,不可以重用的是类的实体、函数的实体、变量的定义等。那么,把可以重用的内容放在h文件中,把不可以重用的放在cpp文件中是一个好办法。
拿类的声明和类的实体为例,如果把一个类的所有内容一古脑放在同一个文件中,将可能出现问题。因为在其它用到类实例的地方都必须让类的声明“可见”,所以我们往往在文件头部加个“#include”,结果类的实体也被编译多次,在连接时产生冲突。
在前文中曾提到过,内联函数是惟一允许(也是必须)在编译时让函数实体可见的的函数。所以内联函数可以放在h文件中。C++规则中有一句正好与此照应:在类的声明中直接写出的函数被认为是内联函数。
Visual C++给类的文件起默认名时,文件名往往与类名一致。如果类名由“C”开头,则文件会是除去开头的“C”字以外的其它文字。如类“CMyClass”,它的代码存放在以下两个文件中:“MyClass.h”和“MyClass.cpp”中。原因是VC++建议类名以C开头,至于为什么在文件名中不出现开头的“C”,可能是出于微软的习惯吧。
标题::类的构造函数
引用:构造函数是特殊的成员函数。
笔记:构造函数的确是一类“特殊”的成员函数。它的特殊性至少表现在以下几个方面:一是它的调用不用程序员操心,只要类对象被创建它就会被调用,而且它不允许被程序员显式地调用。二是它们是必需的,如果程序员偷懒,编译器将自动创建简单的构造函数。三是它们的名字不用程序员多考虑,直接与类名相同。四是它们没有返回值。
下面详说这几个特性:
一、它们在类对象被创建时自动调用,创建对象可能有以下方法:程序中用声明变量的
语句直接声明创建,或者在程序中用new关键字动态创建。这两种方法都可以创建单个对象,也都可以创建对象数组。只要有一个对象被创建,构造函数就被调用一次。
如果程序员想显式地调用构造函数那是不行的。正因为如此,构造函数中还有一种特定的部分叫“初始化列表”,通过它程序员可以调用基类或成员的构造函数。必竟类的设计千差万别,如果某个类的基类或(和)成员有多个构造函数,那么,该类必须能够指定用哪一个构造函数,否则类的功能将大打折扣。调用构造函数不是程序员的事,程序员不应该管也管不了。初始化列表为解决这个问题而生,所以只有构造函数才有初始化列表,其它函数不能有。
上面说到的“大打折扣”究竟是怎样的折扣呢?如果不能指定基类和成员用哪一个构造函数,那就只好让编译器去挑了,构造出来的对象往往不符合要求,只好调用基类和成员的其它函数,比如赋值函数或其它进行参数设定的函数——当然,基类和成员必须包含这样的函数。这样就浪费了资源。
二、类必须包含构造函数——确切地说是必须包含无参数构造函数和拷贝构造函数——原因是因为它们的调用是自动的。如果这两个函数根本就没有,你让系统如何调用?所以,C++也不含糊,你要是懒得写,它就帮你写一个简单的。简单就意味着至少要丧失一些功能,如果类设计得比较复杂(比如包含指针操作)还可能引起灾难性事故。
三、函数名与类名一致。构造函数的名称是必须特殊的,即使这个特殊不表现在与类名相同,也必须找到另一个规则来实现。因为系统要自动调用这些函数,你就必须让系统知道哪些函数是构造函数。
第四个特性直接改变了C/C++语言的一条规则:C语言规定,如果函数没有明显指出返回类型,那么C语言认为返回值是int型。C语言之所以可以有这条规则,一是因为返回int 的函数很多,二是因为即使没有返回值,也必须指明void。当时制定规则的人无法预料到,C++中居然会出现“连void都不是的返回值”的函数,void虽然表示不返回任何值,必竟与类构造函数的“没有返回值”是两码事。于是,C++新标准规定:在定义或声明函数时,没有显式指定返回类型中不合法的。当然类的构造函数除外。
构造函数的出现有它的可行院捅厝恍浴?尚行允怯捎贑++的类允许包含成员函数,既然类可以包含普通的成员函数,那么包含特殊的函数自然也不在话下。必然性是由于类的对象往往必须经过特定的初始化。C++到来之前,C语言中的数据类型只是内置类型。对于内置类型对象,如果忘了初始化,大不了这个对象失去作用,但是不会导致大的问题。比如一个int型值,无论内存如何随机,它的取值范围都不会超过int能表达的范围,对它进行运算也不会产生危险(溢出不能算危险,即使初始化过的数据也不能保证不溢出,而且溢出只是一种逻辑问题)。但是现在的类不这么简单了,忘了初始化往往将带来运行错误。于其每次都要考虑数据的初始化,还不如把这个初始化写成统一的函数,让系统自动调用来得既安全又方便。
标题::类的成员函数
类与C语言中的结构体最大的区别就是类可以带函数,而结构体只是一个内存组合。所以,要提类就不得不提成员函数。
类的成员函数与普通函数(全局函数)相比,最根本的区别是实现了类的封装性。封装性的第一个表现是访问权限:都是函数,但是你能访问哪个不能访问哪个却可以设定。第二个表现是直观,通过类成员(或指针)来调用函数,给人的直觉就是“这是类提供的功能”。你好像“Bird.Fly();”一样一目了然。
在理解this指针以前要想彻底理解成员函数是有困难的,我就曾以为在类的实例中保存
了函数的副本。要不然,为什么同一个类的不同对象调用这个函数有不同的效果呢?原来,在函数所有的形参之外,还有一个不用你操心的参数this,它是一个指针,该指针的目标就是函数的调用者。这么一说就明白了。
函数形参表后加入const就成了“const成员函数”,这样的函数保护了调用者自身不被修改。如CString的GetLength()函数,你只能获取它的长度,不能修改它的内容或长度。加入const的作用倒不是怕调用者修改,而是防止编写函数的人不小心改动了对象。因为百密总有一疏,万一在某个不该修改数据的函数中改变了数据(比如将“==”写成“=”),或者万一调用了另一个非const的成员函数都将可能引起错误。在编写函数前就先加上const可以记编译器来帮你检查。
这个const加在形参表的后面显得有些怪怪的,造成“怪怪的”原因就是因为函数的形参表中没有this,也就没有能用const来修饰的东西了。林锐说“大概是因为其它地方都已经被占用了”并不是根本原因。
标题::内联函数
内联函数应该是为了改善C语言中的宏替换的不足而产生的吧。因为宏替换是预编译中直接展开的,展开过程中将产生意想不到的结果。典型的有“#define MAX(a,b)(a)>(b)?(a): (b)”。“result=MAX(i,j)+2;”将被展开为“result=(i)>(j)?(i):(j)+2;”。虽然外面再加一对括号可以解决以上问题,但是“result=MAX(i++,j);”被展开后将导致i被自增1了两次。(以上例子摘自林锐博士的《高质量C++/C编程指南》第66页,林锐管这叫做“边际效应”)C++用内联来取代宏替换,大大提高了安全性。虽然内联函数也是编译时展开的,但是它能进行安全检查,还能处理类的成员函数(原因是内联函数能够处理this指针,宏却不能)。
引用:内联对编译器来说只是一个建议,编译器可以选择忽略这个建议。
笔记:也就是说,有些函数你想内联,编译器也不一定会采纳。因为内联函数虽然减少了函数调用的开销,却增加了程序的体积。
内联函数是唯一允许实体多次被编译的函数。原因是编译器必须先编译这个函数体,才能在编译函数调用的地方进行合理地展开。这就说明在多个CPP文件组成的工程中,可能有不止一个CPP文件中要有函数的实体。既然这样,就放进头文件吧。
对本文本的评论有:
我觉得象这个max()和以前的数组越界一类的事,都可以归纳为一句话,那就是,C为我们提供了强大的工具,那些不会使用的人才会出现这种错误.连个数组越界也管理不好的,还是去写武侠小说比较好.
比如火药发明了以后,我们可以用来炸山开路什么的,难道因为有人用于战争,就怪这个火药功能不够完善吗?
是这样的,我们不应该怪C标准不好,
虽然它不能让result=MAX(i++,j);这种问题得到解决,
产生i被自增两次这样的结果,程序员应该自己去避免。
但是,如果标准有进步了,我们倒是因为祝贺它一下。
标题::局部对象与静态局部对象
本节首先向读者说明了“名字的作用域”和“对象的生命周期”这两个概念,不难,理解了就行了。前者是空间概念:指程序还处在代码阶段的时候这个名字的可见范围,后者是时间概念:指程序运行过程中对象的存在时间。
函数的形参以及函数内部声明的对象都是局部对象,它们的作用域就是函数内部,但是
它们的生命周期却未必是函数的执行过程。这看起来有点摸不着头脑,原因在于C++的函数中允许存在以关键字“static”声明的静态对象。
也就是说,静态对象是这样一个对象:它的生命周期很长,可以跨越该函数的每次调用,哪怕该函数每24小时才调用一次,它也是全天候存在的。但是要想访问她,却只有函数正在执行的时候才行。
签于以上特性,我专门写了两个测试函数,该函数试途返回局部对象的引用或指针:int&GetInt()
{
int t=3;
return t;//警告
}
int*GetInt2()
{
int t=3;
return&t;//警告
}
以上两个警告产生的原因是函数返回了临时对象的引用或地址。但是如果将t的声明改成“static int t=3;”就不再显示警告。
静态局部对象似乎为节约系统开销做了准备。不过我认为这个特性不应该被滥用。只有确实有必要让对象生命周期跨越多次调用时才应该把它声明为静态(比如统计函数被调用的次数)。否则将提高造成BUG的可能性,使“高效率”的程序成为空中楼阁。
标题::默认实参
没什么比偷懒更舒服的了,所以我喜欢允许默认实参的函数,我还喜欢写允许默认实参的函数。
在形参表中,如果允许某些形参具有默认值,则它们必须按从右到左的方向排列。以上这个规定C++与BASIC是一样的,但是C++与BASIC还有一点区别,就是在函数调用时,C++必须从右边开始缺省实参,而BASIC却可以任意缺省而不顾次序(只要有逗号表示那里缺了个东西即可)。所以,同样设计函数,C++比BASIC要多考虑一个问题:“设计带有默认实参的函数,其中部分工作就是排列形参,使最少使用默认实参的表参排在最前,最可能使用默认实参的形参排在最后。”
形参的默认值竟究写在声明中还是实体中?我曾经试过,在某些情况下写在声明中或实体中一样可行。但是,事实上写在实体中是错误的做法。只有当函数实体和函数调用在同一个源文件中,而且函数实体在调用前被编译时,将形参的默认值写在实体中才可通过编译。实际上对于这种情况,函数根本就不用声明。
将默认值写在实体中不仅仅是能否通过编译的问题,还关系到程序设计的理念。“一是函数的实现本来就与参数是否有缺省值无关,所以,没有必要让缺省值出现在函数的定义体中。二是参数的缺省值可能会改动,显然修改函数的声明比修改函数的定义要方便。”(《高质量C++/C编译指南》第63页)
读到这里,本书给了我一个大大的惊诧:原来默认实参的默认值还可以是任何表达式。以前,我一直是这样写的:“int GetInt(int i=3);”虽然没人跟我这样说过,但是我始终以为后面的默认值只能是常量。想不到还可以是需要求值的变量甚至是更复杂的表达式:
int GetInt(const int i=3);
int GetInt2(const int j=GetInt());//居然可以这样写
学习了,感谢《C++Primer》!
标题::函数的声明与实体
注:本书中提到了“声明”与“定义”两个词。我倒是认为将后者改为“实体”更好。
函数的实体就是实实在在的函数内容,它规定了这个函数怎样执行,这没有什么好说的。那么函数为什么还要有声明呢?
这样做的目的之一是告诉编译器:虽然你还没有见到函数本身,不知道函数是怎样执行的,但是我先告诉你这个函数的名称、参数与返回值,你就先编译吧。至于这个函数究竟干什么,等到连接的时候再说。
设计合理的程序,其代码存放在不同的文件中,函数的实体只能有一个,存放在某一个源文件中。其它源文件中如果要用到这个函数,就在这个文件中加入函数的声明。
这样做的目的之二是函数的提供者与使用者往往不是同一个人,甚至不是同一个企业。出于种种目的,函数的提供者可能并不想(或不必)让使用者知道这个函数的具体内容,只要使用者能调用就行。这种情况下,函数的提供者只需要提供一个声明给使用者即可。——C 语言的库函数就是这样的。
然而“在需要用到函数的文件中加入函数的声明”也有好办法与笨办法。将声明语句重写一遍自然不难,但是这样做有两个明显的缺点:一是烦琐易错、二是不易修改。所以,函数的声明应该放在头文件中,哪儿要,就在哪儿包含。这就好像我家没有摆许多盆鲜花而是摆了许多面镜子。我在哪儿都能看到鲜花,浇水却只要浇一盆。
这个理论也适用于C++的“类”,类的声明写进头文件,而实体却写进程序文件。不同的是,类的声明不像函数的声明那样只有一句话,而是一个完整的结构。
标题::递归
引用:直接或间接调用自己的函数称为递归函数。
引用:递归函数必须定义一个终止条件,否则函数将永远递归下去,这意味着函数会一直调用自身直到程序耗尽。
初识递归的时候,的确有些不容易搞明白。记得当时的教科书为此画一个图,用一组箭头来表示要计算A必须先计算B、要计算B又要先计算C、……,用另一组箭头表示算好了C就可以算B、算好了B就可以算A。……实例程序与一个图结合,如此摆事实讲道理,要说明递归自然稍容易些。
要写递归函数就得领悟递归的妙用,要写没有错误的递归函数则要领悟其数学原理。我倒是觉得这样的函数与“数学归纳法”有些相通之处。不同的是,数学归纳法总是先求边界条件,再去往无穷方向归纳。而递归是从无穷方向向边界计算的。函数如何执行,与我们如何写没有必然的关系,于是,我们在写程序的时候也可以先写边界条件。这样做可以在程序开头先把可能的问题给排除掉。“永远递归下去”的可能性自然被降低。比如求阶乘的函数://程序一、书上的例子
int factorial(int val)
{
if(val>1)
return factorial(val-1);
return1;
}
//程序二
int factorial2(int val)
{
if(val<=1)
return1;
return factorial2(val-1);
}
程序二的写法与程序一没有区别,但可以告诉自己递归必须有终止条件。防止一不小心就写了个“永远”。
似乎绝大多数递归函数都可以用循环来解决。这两种方法迁就了不同的对象:循环用少量的计算机资源、大量的人力来解决问题,递归则用大量的计算机资源、少量的人力来解决问题。所以,在计算机速度和存储量都不大的年代,曾有人反对递归。
汉诺塔问题据说是只有用递归才可以解决的问题,其实只有要求解汉诺塔的移动过程才必须用递归,如果只要求解移动次数,那么用循环也不成问题。
对本文本的评论有:
阶乘的函数写错了.
int factorial(int val)
{
if(val>1)
return val*factorial(val-1);
return1;
}
晕,我忘了相乘了,哈哈。
标题::return语句
引用:return语句用于结束当前正在执行的函数,并将控制权返回给调用此函数的函数。
引用:return语句有两种形式:reutrn;return expression;……第二种形式提供了函数的结果。
笔记:以上第一句话说了return的两个作用之一:结束函数。return的作用之二是提供函数的返回值。
对于return语句的两种形式,情式一只能用于无返回值的函数,情式二可以用于有返回值的函数也可用于无返回值的函数。
如果函数有返回值,就必须用形式二来结束,这是显而易见的。
对于没有返回值的函数,可以不写return语句,“隐式的return发生在函数的最后一个语句完成时”。也可以用形式一来结束,这种用法一般用在函数中间,判断某些条件之后就立即结束,后面的语句不再执行。如果用形式二来返回,那么express必须是另一个没有返回值的函数。如:
void FuncA();
void FuncB()
{
return FuncA();
}
个人认为这种写法不是好习惯,因为看起来FuncB有了返回值,如果逻辑上有这需要,我认为写成以下格式更好:
void FuncB()
{
FuncA();
return;
}
在BASIC中,函数的返回值与结束是由两个不同的语句实现的。前者是一个给函数名赋值的语句,后者则是“Exit Function”语句。这种设计除了不如C++精练以外,还容易出事。比如在函数开头先给函数名赋一个默认值,然后根据某些条件给它赋其它特定的值并Exit。如果写函数时不小心漏了某个赋值语句,函数将产生BUG。C++则不会产生这种类型的BUG。
引用:千万不要返回局部对象的引用。
引用:千万不要返回局部对象的指针。
笔记:以上两句是黑体的标题:,书中专门进行了讨论。不过这个错误虽然严重,却不难理解。知道了就好了。
main()是一个很特殊的函数,它的特殊性在这里还有体现。引用:“返回类型不是void 的函数必须返回一个值,但此规则有一个例外的情况:允许主函数main没有返回值可结束。……编译器会隐式地插入返回0的语句。”
标题::传递数组的函数与字符串函数
如果将数组作为实参来调用函数,函数接收到的形参其实是一个指针。数组名是可以转换为指针的,但是数组名和指针毕竟不等价。所以,这样传递的结果是丢失了数组原有的一些特性。最大的损失莫过于sizeof对数组大小的测试。试看以下程序:
void FuncA(int*temp)
{
cout< } void FuncB(int temp[]) { cout< } void FuncC(int temp[20]) { cout< } int main() { int a[10]; cout< FuncA(a); FuncB(a); FuncC(a); return0; } 三个函数的写法各有不同,但是结果却是一样的。其中FuncC的写法尤其容易产生误解。因为编译器不管你传递的是多大的数组(甚至不管是不是数组),但是函数的写法却在暗示程序员这个数组有20个成员。如果实参成员超过20个,结果就是没有起到完全的作用, 如果实参成员不到20,那就指针越界了。 为避免这样的尴尬,有时我们将指针与容量一起传入函数:“void FuncD(int temp[], _size_t Size);”,或者传递两个指针:“void FuncE(int*Begin,int*End);”。这样做当然好,不过C++还有另一种办法可以不用这么麻烦,那就是引用传递:“void FuncF(int(&temp)[10]);”。这样的函数只允许将int[10]实参传入,大小不符的数组或非数组的指针都无法传入。这样就保证了10这个值的正确性,连sizeof都省了。 C语言的字符串处理函数大概是仅有的可以不受此约束的函数了。字符串就是字符数组,但是在传递字符数组时,可以只传指针而不管大小。因为C语言中的字符串都是以NULL 尾的。前阵子有人在论坛提问,问及字符串和字符指针的关系。回答是:C语言的字符串是用字符数组存放的,而处理则是借助于字符指针。但是,要能进行这样的操作,有两个条件必须满足:一是所有字符连续放置在以指针开头的内存中、不跳跃,二是有一个规定的结束符。int[]数组之所以不能这样做,是因为第二个条件无法满足。 标题::函数的引用返回值 引用是给变量取一个别名,所以引用传递会直接进行变量本身的传递。它的最大好处是可以把别处对变量的改变保留下来,第二好处是它提高了性能:如果函数的返回值是一个引用,那么,如上文所说,它会节约一组构造、赋值和析构过程。但是,函数返回引用往往会带来一些意想不到的错误:比如返回临时变量的引用。 //一个错误的函数 int&Max(int i,int j) { return i>j?i:j; } 以上函数的错误在于,i和j在函数结束后会被释放。对它们的引和也将失效。如果用这个返回值给别的变量赋值,将会获得一个垃圾。VC++.Net会对以上return语句显示警告。 那么,如果返回一个全局变的引用呢?这当然是可以的,但是,一来程序设计中不建议使用过多的全局变量,二来全局变量即使不返回也可以访问。这样做的唯一用途就是把函数做右值来给其它变量赋值。 int m;//全局变量 int&MaxByGlobal(int i,int j) { return m=i>j?i:j; } int a,b,c; c=MaxByGlobal(a,b);//用法一、用返回值赋值 MaxByGlobal(a,b);c=m;//用法二、不用返回值赋值 当然,以上这个MaxByGlobal函数也不是一无是处,能用返回值来进行赋值会给程序带来更好的可读性。只是这样的函数设计本身不被建议。 那么,函数返回引用用得最多的就是返回形参了。因为形参可以用引用传递,引用的形参不是函数内部的局部变量,这样做是可取的: int&MaxByRef(int&i,int&j) { return i>j?i:j; } 上面这个函数和上文中的“int Max(int i,int j)”函数如此相似,但是它省去了三次构造、赋值和析构。 另外一种用法就是在类的成员函数中返回类对象自身了,典型的是“operator+=”函数之类。 MyClass&MyClass::operator+=(const MyClass&other) { //某些语句 return*this; } 以上函数返回的是自身的引用。因为类的成员函数也可以写成全局函数“MyClass &operator+=(MyClass&Left,const MyClass&right)”,而且在类成员函数的调用中实际存在着this指针的传递。所以,以上这个函数依然可以看作返回了形参的引用。 对于返回引用的函数,还有一个好玩的现像。即返回值还可能可以被赋值。如“(a+=b) =c;”这样的形式。这种写法明显不伦不类,但是如果函数返回了非const的引用,这个表达式的确是合理的。所以,上面的“operator+=”函数还要修改一下,将返回值由“MyClass&”改为“const MyClass&”。 返回引用并不是处处可用的,正如《引用传递的应用范围》中提到的一样:不能用引用来传递临时值。有时候我们的确要产生一个临时对象并返回它,那就不能返回引用。典型的有“operator+”函数: const MyClass MyClass::operator+(const MyClass&other)const { MyClass Temp; //某些语句 return Temp;//这里只能返回对象,因为Temp必须是局部变量 } 标题::函数的非引用返回值 函数最多可以返回一个值,也可以不返回任何值(也有“返回void”的说法)。之所以最多只能返回一个值,因为只有这样才能在表达式中使用。比如“y=Sin(x);”,如果Sin函数返回多个值,这个表达式就失去了意义。之于为什么可以不返回任何值,经历过BASIC的人应该更能理解。因为BASIC中把有返回值的程序段叫函数,没有返回值的程序段则叫做“子程序”。很显然,“子程序”就是完成一个特定的功能后结束的程序段。 函数的返回值没有类型限制,可以是内置类型变量,也可以是类对象。无论是内置类型还是类对象,都有着一样的规律。但是,这些规律在C++到来之前很少有人去理会,毕竟内置变量类型太复通,以至于程序员根本不去考虑那么多“为什么”。 在C时代,所有的返回值都是局部变量。如下列程序: //程序一: int Max(int i,int j) { return i>j?i:j; } //程序二: char*StrCpy(char*Target,const char*Source) { char*Temp=Target; while(*Source) { *Temp++=*Source++; } return Target; } 程序二给人一个错觉:认为该函数返回的不是函数内部的局部变量。错误原因在于没有理解指针的本质。其实程序二和程序一一样,返回值是形参之一。而形参就是作用域为函数内部的局部变量。 理解了“返回值是局部变量”还不够。因为还有一个很重要的概念没弄清。比如: int a,b,c; char d[10],e[10],*f; //其它语句 c=Max(a,b);//语句一 f=StrCpy(d,e);//语句二 以上注释的两行语句都有同一个问题:如果返回的变量作用域仅限于函数内部,那么函数结束以后该变量就已经不存在了,那么给c和f赋值的是什么? C和C++有一个机制保证以上赋值正常进行:在函数结束前,先将要返回的局部变量临时拷贝一份到栈内存(这个内存程序员无须知道,也无法知道)。然后将局部变量销毁,函数正常结束。接下来用栈中的临时变量对目标变量进行赋值,赋值结束后再把临时变量销毁。 以上这个过程凭空多出一次变量构造、复制与销毁过程,好在对于内置类型变量来说,这样的过程所需的性能赋出并不太多。但是C++到来以后,函数的返回值类型可以是类类型。而类对象的构造、复制与销毁可能很复杂、很占用系统资源。于是“引用传递”再一次发挥了它的威力。 标题::引用传递的应用范围 经过三篇文章的细述,函数的参数传递应该比较明朗了,经过一番对比,似乎引用传递是最优秀的一种传递方式。第一、它用法很简单,类似于值传递,第二、它功能很强大,类似于指针传递,第三、它很安全,可以避免指针传递带来的危险,第四、它效率高,函数中不必要进行对象的创建、赋值与释放。第五、如果不希望实参被改变,可以使用const修饰形参…… 但是,天下没有这么便宜的午餐!引用传递不是倒处能用的。举个例子: void Swap(int&a,int&b) { int temp=a; a=b; b=temp; } 以上函数可以进行两个int变量的交换。但是,很多情况下该函数不能调用: int ia=ib=1; short sa=sb=2; const int cia=cib=3; Swap(ia,ib);//正确 Swap(sa,sb);//错误,short不是int,虽然可以隐式转换为int,但是这个变量不存在 Swap(cia,cib);//错误,这两个参数是const的 Swap(4,5);//常量不是变量,类似于将short变量传递给函数 Swap(ia+ib,ia-ib);//错误,表达式求值后产生的临时值不是变量 其中将const参数传递进函数的做法,虽然看起来有些荒诞,实际上某些时候会不经意间做的。某个变量在定义的时候并不是const的,但是在调用某个函数的时候将它作为const 形参传入,而该函数内部再调用Swap()函数时,这个变量已经成了局部的const变量。 以上这个特性反过来应用是很有用的。在多人协作写程序的时候,或者写一个大型程序的时候。你不知道某函数是否用const来保护参数,但是你想保护参数。那么,你就在自己写的原调函数中将该参数保护起来。这样,当你调用某个没有显式指定const引用参数的函数时,编译器就会报错。 void funca(const int&a) { funcb(a);//发生错误 } void funcb(int&b) { ...; } int t; funca(t); 以上程序会在注释的那行停止编译。因为在它调用了函数b,而b没有声明参数为const。虽然函数b中未必改动参数。 标题::形参与实参的关系之引用传递 C++有了“引用传递”后,“形参的改变不影响实参”被判无效。因为传递给函数的并不是一个值,而是变量自身。在函数中定义的形参虽然还是局部变量,但却是一个引用。虽然这个引用的作用域仅限于函数内部,但是由于它与实参就是同一回事,所以对它的操作完全等同于对实参的操作。比如你叫“黑旋风”去买鱼,或者叫“铁牛”去买鱼,去的都是同一个人。 C++为什么要有“引用传递”这回事?一种说法是只有引用才能达到操作符重载的目的,这个以后再谈。但是,撇开这个不谈,形参是不是引用,直接影响了程序执行的效率。前面提到过,函数调用时要用实参的值去初始化形参,初始化的过程包含了定义一个变量、然后给它赋一个值两个过程,如果这个变量并不是内部变量,而是一个类对象,那么,定义一个类对象可能很复杂,而初始化这个对象一样会很复杂。而引用只是给对象取一个别名,不涉及定义与初始化,离开作用域时也不用释放。 相比之下,用指针传递可以避免类对象的定义、初始化与释放。只需要付出指针变量的定义、初始化与释放的代价。但是,指针的杀伤力太大。即使是熟练的程序员,也不能保证绝不出现“野指针”,野针的代价几乎无一例外是程序崩溃。 引用也不是吃素的,如果说指针传递是“帮你配了一把我家的钥匙”,那么引用传递就是直接把我家的财产都交给了你。有时,我们使用引用传递仅仅是为了效率,而不希望实参被修改,那就要记得把形参标记为const,如“UINT GetLength(const CString&)”。 顺便说一句,指针传递也可以这样做。把形参定义为指向const对象的指针(而不是const 指针),可以降低杀伤力,保护实参所对应的内存。如果是普通的值传递,那么有没有const 对函数外部并不影响。但是,我个人认为,有时候加上const也是一件好事。如果程序的逻 辑并不需要改变参数,而实际上误写了代码,加上const可以让编译器帮我们找出BUG,如:int Max(const int a,const int b) { return a>b?a:b; } VB没有指针的概念,却有“值传递”和“地址传递”两个概念。比如“Function Func(ByRef i As Integer)As Integer”,变量i接受了实参后,它的改变能影响实参。它的实质就类似于C++中的引用传递。 标题::形参与实参的相互关系 “形参的改变不影响实参”这句话说起来轻巧,但是要完全理解,似乎还有几个玄机。 在我发表《函数的定义》一文后,有朋友发表意见,提到了“函数调用过程中的入栈与出栈”,在此首先作个说明:我读的是《C++Primer》,而不是《编译原理》,入栈与出栈不归我讨论。在现在讨论的尺度内,我们可以这么认为:形参是函数内部的一个局部变量,该局部变量在函数开始执行时被初始化,而初始化它的值则来自实参的值。也就是说,它的定义与初始化类似于“int i=3;”。只是被分成两行写了,形参的定义写在函数的定义中,如:“int ttt(int b)”,初始化写在了调用中“cout< 那么,在函数中无论怎样改动b的值,被改的始终是形参这个局部变量,函数结束时,离开这个局部变量的作用域,变量被释放。 但是,C语言的“指针传递”总是给人“形参能改变实参”的感觉,其实这是一个误解。对于指针传递来说,函数的形参是一个指针,传给它的实参也应该是指针(或者能转为指针的值,比如数组名、能转换为指针的类等)。在函数中,如果改变了该指针(对指针的改变就等同于让这个指针指向别处),不会影响主调函数中的实参。但是,由于指针对应着一个内存地址,通过它可以改变内存的内容。所以,无论在函数内部的形参还是外部的实参,它们都可以影响同一内存的值。所以,指针传递可以把函数内部的影响带到函数外,但是,带到函数外的绝不是形参,而是形参所指的内存。 这就好比我把我家的钥匙给你配了一把,我手里的钥匙是实参,你手里的钥匙是形参。你无论是把钥匙折断还是磨短,都与我的钥匙无关,但是你用它开了我家的门却可以把我家洗劫一空。你影响的不是我的钥匙,而是我的财产。 上文说到,C++有了“引用传递”后,“形参的改变不影响实参”被判无效。这就得提到“引用传递”的概念了,下文再续。 对本文本的评论有: 简单地说,每次调用函数的时候,形参把实参克隆了一次,你再怎么折腾形参,也与实参无关. TNND就是一个入栈与出栈过程嘛,你可以去学学汇编. 举例: mov cs1,100//cs1=100; push cs1//把cs1入栈; pop cs2//把栈中的内容出栈给cs2; 这与另一句话等价: mov cs1,100 mov cs2,cs1 为什么会使用上面的那种用法呢? 因为push和pop占用更少的CPU周期.所以,一般调用函数都用入/出栈来备拷贝参数. 标题::形参与实参概念 说到形参与实参,在C++出来之前其实很简单,就一句话:形参的改变不影响实参。这个状态直到C++有了“引用传递”才有改变。 要弄清这个,首先得弄清形参与实参是什么东西。因为函数是一段“可以重用而不必重写”的代码,每次重用当然未必完全相同(不可否认有些函数每次重用都完全相同),那么不同在哪里呢?又怎样产生不同呢?一种方法是依靠随机,随机是个好东西,不要说客户了,连程序员都无法控制每次调用的结果。第二种方法是凭客观条件(比如运行时间、机器配置)。但是这些函数应用很窄,类似于“y=Sin(x)”这样的函数就绝不能这样做。 那么,从“y=sin(x)”的形式看来,能决定函数怎样运行的唯一因素就是x的值了。函数的某次运行是受某一个x值的影响并控制的,而下一次运行,则会受另一个x值的影响。那么,调用函数者就有必要告诉函数:我要用哪个值来控制你,而函数自己则有必要保存这个值,直到函数结束。 为此,在函数内部建立一个临时的、局部的变量,该变量的作用域就是函数内部,该变量的作用时间就是从函数开始执行到结束执行。如果同一函数在同一时间有几个副本在执行(这种情况在多线程程序中会出现),那么它们是互不相干的,它们内部的变量也是互不相干的。这个变量就叫做“形参”,全称形式参数。 “形式”是跟“实际”相对的,另一个参数就是实际参数,叫“实参”,在调用函数时,这个值将决定函数内部的形参的值。实参在函数中是否可见?这要取决于两个因素:一是实参的作用域,二是有没有被形参覆盖。先说第一个因素,如果只谈C语言,那么所谓的作用域就是全局与局部两种,但是C++中还有“类作用域”这一概念,由此第一个因素变得复杂了。第二个因素本身并不复杂,但是如果没有引起程序员的注意,那么造成的问题是很难发现的。试看下以下程序: int a;//全局变量 int ttt(int a)//该函数的形参也叫a {