教你从C轻松到C++(一)

发表于 2014-10-29 14:55:39

教你从C轻松到C++(一)

摘要C++技术固然是很时髦的，许多C用户都想在尽可能短的时间内为自己贴上C++的标签。介绍C++的书很多，但只有那些已经侥幸入门的用户才偶尔去翻翻，仍有不少在C++门口徘徊的流浪汉。　　本文只针对C用户，最好是一位很不错的老用户（譬如他在遇到最简单的问题时都尝试着使用指针），通过一些C和更好的C++（本文用的是Borland C++3.1版本）例程介绍有关C++的一些知识，让读者朋友们“浅入深出”，轻轻松松C to C++！
　　一、标签！标签！
　　快快为你的程序贴上C++的标签，让你看起来很像个合格的C++用户……
　　 1.注释（comment）
　　 C++的注释允许采取两种形式。第一种是传统C采用的/*和*/，另一种新采用的则是//，它表示从//至行尾皆为注释部分。读者朋友完全可以通过//使你的代码带上C++的气息，如test0l：　//test01.cpp
#include <iostream.h>
//I'm a C++user!
//…and C is out of date.

void main()
{
　　　　　　 cout<<"Hello world!n"; //prints a string
}
　　 Hello-world！
　　如果你尝试着在test0l. exe中找到这些高级的注释，很简单，它们不会在那里的。
　　 2. cincout
　　你可能从test0l中嗅出什么味儿来了，在C++中，其次的贵族是cout，而不是很老土的printf （）。左移操作符‘<<’的含义被重写，称作“输出操作符”或“插入操作符”。你可以使用‘<<’将一大堆的数据像糖葫芦一样串起来，然后再用cout输出：
　cout << "ASCII code of "<< 'a' << " is:" <<97;

ASCII code of a is:97
　　如何来输出一个地址的值呢?在C中可以通过格式控制符”%p”来实现，如:
　　 printf ("%p，&i);
　　类似地，C++也是这样:
　　 cout << & i;
　　但对字符串就不同啦!因为:
　　 char * String="Waterloo Bridge";
　　 cout << String; //prints ‘Waterloo Bridge'
　　只会输出String的内容。但方法还是有的，如采取强制类型转换:
　　 cout<<(void *)String;
　　 cin采取的操作符是’>>’，称作“输入操作符”或“提取操作符”。在头文件iostream.h中有cin cout的原型定义，cin语句的书写格式与cout的完全一样:
　　 cin>>i; //ok
　　 cin>>&i; //error. Illegal structure operation
　　看到了?别再傻傻地送一个scanf()常用的’&’地址符给它。
　　 C++另外提供了一个操纵算子endl，它的功能和’n’完全一样，如test0l中的cout语句可改版为:
　　 cout << ”Hello world!”<
　　 3.即时声明
　　
　　这是笔者杜撰的一个术语，它的原文为declarations mixed with statements，意即允许变量的声明与语句的混合使用。传统C程序提倡用户将声明和语句分开，如下形式:
　int i=100;
float f; //declarations
i++;
f=1.0/i; //statements　而C++抛弃这点可读性，允许用户采取更自由的书写形式：　int i=100;
i++;
float f =1. 0/i;　　即时声明常见于for循环语句中： for(int i = 0; i < 16; i++)
　　　　　　　　　　　　　 for(int j = 0; j < 16; j++)
　　　　　　　　　　　　　　　　　　　　 putpixel(j i Color[j]);

　　这种形式允许在语句段中任点声明新的变量并不失时机地使用它（而不必在所有的声明结束之后）。
　　特别地，C++强化了数据类型的类概念，对于以上出现的“int i=1 j=2；”完全可以写成：int i（1） j （2）；再如：　char * Stringl("Youth Studio.”);
char String2[]("Computer Fan.“);
　　这不属于“即时声明”的范畴，但这些特性足以让你的代码与先前愚昧的C产品区别开来。
　　 4.作用域（scope）及其存取操作符（scope qualifier operator）
　　即时声明使C语言的作用域的概念尤显重要，例如以下语句包含着一条错误，因为ch变量在if块外失去了作用域。　if(ok)
　　　　　　　　　　　　　 char ch='!';
　　　　　　 else
　　　　　　　　　　　　 ch='?'; //error. access outside condition
　　作用域对应于某一变量的生存周期，它通常表现为以下五种:
　　块作用域
　　开始于声明点，结束于块尾，块是由{}括起的一段区域
　　函数作用域
　　函数作用域只有语句标号，标号名可以和goto语句一起在函数体任何地方函数原型作用域
　　在函数原型中的参量说明表中声明的标识符具有函数原型作用域
　　文件作用域
　　在所有块和类的外部声明的标识符(全局变量)具有文件作用域
　　类作用域
　　类的成员具有类作用域
　　具有不同作用域的变量可以同名，如test02:
　//test02.cpp
#include <iostream.h>
int i=0;
void main()
{
　　　　　　 cout << i << ' '; //global 'int i' visible
　　　　　　 {
　　　　　　　　　　　　 float i(0.01); //global 'int i' overrided
　　　　　　　　　　　　　 cout<< i << ' ';
　　　　　　 }
　　　　　　 cout<<i<<endl; //global 'int i' visible again
}
0 0.01 0
　　编译器并未给出错误信息。
　　作用域与可见性并不是同一概念，具有作用域不一定具有可见性，而具有可见性一定具有作用域。
　　在test02中，float i的使用使全局int i失去可见性，这种情形被称作隐藏（override）。但这并不意味着int i失去了作用域，在main（）函数运行过程中，int i始终存在。
　　有一种办法来引用这丢了名份的全局i，即使用C++提供的作用域存取操作符：：，它表示引用的变量具有文件作用域，如下例程： 　//test03.cpp
#include <iostream.h>
enum {boy girl};
char i = boy;
void main()
{
　　　　　　 {
　　　　　　　　　　　　　 float i(0.01);
　　　　　　　　　　　　　 cout << "i=" << i << endl;
　　　　　　　　　　　　　　　　　　　　 ::i=girl; //modify global 'i'
　　　　　　 }
　　　　　　 cout << "I am a " << (i ? "girl." : "boy.");
}

i=0.01
I am a girl.　在上例中，通过：：操作符，第8行语句偷偷地改写了i所属的性别。更妙的是，：：之前还可以加上某些类的名称，它表示引用的变

发表于 2014-10-29 14:56:00

教你从C轻松到C++(二)


 量是该类的成员。　　 5. new delete
　　许多C用户肯定不会忘记alloc（）和free（）函数族，它们曾经为动态内存分配与释放的操作做出了很大的贡献，如：　char *cp = malloc(sizeof(char));
int *ip=calloc(sizeof(int) 10);
free(ip);
free(cp);
　　 C++允许用户使用这些函数，但它同时也提供了两个类似的操作符new和delete，它们分别用来分配和释放内存，形式如下：p = new TYPE；delete p；因此以上的cp操作可改版为：char*cp=new char；delete cp；new delete操作符同样亦可作用于C中的结构变量，如：struct COMPLEX*cp = new struct COMPLEX；delete cp；当不能成功地分配所需要的内存时，new将返回NULL.对于字符型变量可以如下初始化：char ch（'A'）； //char ch='A'对应地，new可以同时对变量的值进行初始化，如：char p=new char （'A‘）； //cp='A' new不需要用户再使用sizeof运算符来提供尺寸，它能自动识别操作数的类型及尺寸大小，这虽然比malloc）函数聪明不了多少，但起码使用起来会比它方便得多。当然，正如calloc（）函数，new也可以用于数组，形式如下：p = new TYPE[Size] ；对应的内存释放形式：delete [] p；同理首例中ip操作可以改版为：int * ip=new int[10]；delete [] ip；用new分配多维数组的形式为：p = new TYPE [c0] [c1]…… [cN]；从来没有太快活的事情，例如以下使用非法：int***ip2=（int***）new int[m] [n][k]； //error. Constant expression required int***ip 1=（int***）new int[m][2][81； //ok C++最多只允许数组第一维的尺寸（即c0）是个变量，而其它的都应该为确定的编译时期常量。使用new分配数组时，也不能再提供初始值：char*String =new char[ 20] （"Scent of a Woman"）； //error： Array allocated using 'new' may not have an initializer 6.引用（reference）
　　（1）函数参数引用以下例程中的Swap（）函数对数据交换毫无用处：　//test04. cpp
#include <iostream.h>
void Swap(int va int vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << " b=" <　　 b=2c语言对参数的调用采取拷贝传值方式，在实际函数体内，使用的只是与实参等值的另一份拷贝，而并非实参本身（它们所占的地址不同），这就是Swap（）忙了半天却什么好处都没捞到的原因，它改变的只是地址0x0012FF24和0x0012FF28处的值。当然，可采取似乎更先进的指针来改写以上的Swap （）函数：　//test05. cpp
#include <iostream.h>

void Swap(int * vap int * vbp)
{
　　　　　　 int temp = *vap;
　　　　　　 *vap = *vbp;
　　　　　　 *vbp = temp;
　　　　　　 cout << "vap=" << vap << "vbp=" <<vbp << endl;
　　　　　　 cout << "&vap=" << &vap << "&vbp=" << &vbp << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 int * ap = &a * bp = &b;
　　　　　　 cout << "ap=" << ap << "bp=" << bp << endl;
　　　　　　 cout << "&ap=" << &ap << "&bp=" << &bp << endl;
　　　　　　 Swap(ap bp);
　　　　　　 cout << "a=" << a << "b=" << b <<endl;
}
ap=0x0012FF7Cbp=0x0012FF78
&ap=0x0012FF74&bp=0x0012FF70
vap=0x0012FF7Cvbp=0x0012FF78
&vap=0x0012FF1C&vbp=0x0012FF20
a=2b=1在上例中，参数的调用仍采取的是拷贝传值方式，Swap（）拷贝一份实参的值（其中的内容即a b的地址），但这并不表明vapvbp与实参apbp占据同一内存单元。　　对实际数据操作时，传统的拷贝方式并不值得欢迎，C++为此提出了引用方式，它允许函数使用实参本身（其它一些高级语言，如BASIC FORTRAN即采取这种方式）。以下是相应的程序：　//test06. cpp
#include <iostream.h>
void Swap(int & va int & vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << "b=" <　　对int&

发表于 2014-10-29 14:56:07

教你从C轻松到C++(三)

amp;的写法别把眼睛瞪得太大，你顶多只能撇撇嘴，然后不动声色地说：“就这么回事！加上&就表明引用方式呗！”（2）简单变量引用简单变量引用可以为同一变量取不同的名字，以下是个例子：int Rat；int & Mouse=Rat；这样定义之后，Rat就是Mouse（用中文说就是：老鼠就是老鼠），这两个名字指向同一内存单元，如：Mouse=Mickey； //Rat=Mickey一种更浅显的理解是把引用看成伪装的指针，例如，Mouse很可能被编译器解释成：*（& Rat），这种理解可能是正确的。　　由于引用严格来说不是对象（？！），在使用时应该注意到以下几点：①引用在声明时必须进行初始化；②不能声明引用的引用；③不能声明引用数组成指向引用的指针（但可以声明对指针的引用）；④为引用提供的初始值必须是一个变量。
　　当初始值是一个常量或是一个使用const修饰的变量，或者引用类型与变量类型不一致时，编译器则为之建立一个临时变量，然后对该临时变量进行引用。例如：　int & refl = 50; //int temp=50 &refl=temp
float a=100.0;
int & ref2 = a; / / int temp=a&ref2=temp
　　（3）函数返回引用函数可以返回一个引用。观察程序test07：　//test07.cpp
#include <iostream.h>
char &Value (char*a int index)
{
　　　　　　 return a[index];
}

void main()
{
　　　　　　 char String[20] = "a monkey!";
　　　　　　 Value(String 2) = 'd';
　　　　　　 cout << String << endl;
}

a donkey!　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。

　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED

发表于 2014-10-29 14:56:18

教你从C轻松到C++(四)

XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　对实际数据操作时，传统的拷贝方式并不值得欢迎，C++为此提出了引用方式，它允许函数使用实参本身（其它一些高级语言，如BASIC FORTRAN即采取这种方式）。以下是相应的程序：　//test06. cpp
#include <iostream.h>
void Swap(int & va int & vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << "b=" << b << endl;
}

&a=0x0012FF7C&b=0x0012FF78
&va=0x0012FF7C&vb=0x0012FF78
a=2b=1
　　很明显，a b与vavb的地址完全重合。
　　对int&的写法别把眼睛瞪得太大，你顶多只能撇撇嘴，然后不动声色地说：“就这么回事！加上&就表明引用方式呗！”（2）简单变量引用简单变量引用可以为同一变量取不同的名字，以下是个例子：int Rat；int & Mouse=Rat；这样定义之后，Rat就是Mouse（用中文说就是：老鼠就是老鼠），这两个名字指向同一内存单元，如：Mouse=Mickey； //Rat=Mickey一种更浅显的理解是把引用看成伪装的指针，例如，Mouse很可能被编译器解释成：*（& Rat），这种理解可能是正确的。
　　由于引用严格来说不是对象（？！），在使用时应该注意到以下几点：①引用在声明时必须进行初始化；②不能声明引用的引用；③不能声明引用数组成指向引用的指针（但可以声明对指针的引用）；④为引用提供的初始值必须是一个变量。
　　当初始值是一个常量或是一个使用const修饰的变量，或者引用类型与变量类型不一致时，编译器则为之建立一个临时变量，然后对该临时变量进行引用。例如：　int & refl = 50; //int temp=50 &refl=temp
float a=100.0;
int & ref2 = a; / / int temp=a&ref2=temp
　　（3）函数返回引用函数可以返回一个引用。观察程序test07：　//test07.cpp
#include <iostream.h>
char &Value (char*a int index)
{
　　　　　　 return a[index];
}

void main()
{
　　　　　　 char String[20] = "a monkey!";
　　　　　　 Value(String 2) = 'd';
　　　　　　 cout << String << endl;
}

a donkey!　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。

　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这

发表于 2014-10-29 15:00:26

教你从C轻松到C++(五)


 种情况下，函数允许用在赋值运算符的左边。　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　 5. new delete
　　许多C用户肯定不会忘记alloc（）和free（）函数族，它们曾经为动态内存分配与释放的操作做出了很大的贡献，如：　char *cp = malloc(sizeof(char));
int *ip=calloc(sizeof(int) 10);
free(ip);
free(cp);
　　 C++允许用户使用这些函数，但它同时也提供了两个类似的操作符new和delete，它们分别用来分配和释放内存，形式如下：p = new TYPE；delete p；因此以上的cp操作可改版为：char*cp=new char；delete cp；new delete操作符同样亦可作用于C中的结构变量，如：struct COMPLEX*cp = new struct COMPLEX；delete cp；当不能成功地分配所需要的内存时，new将返回NULL.对于字符型变量可以如下初始化：char ch（'A'）； //char ch='A'对应地，new可以同时对变量的值进行初始化，如：char p=new char （'A‘）； //cp='A' new不需要用户再使用sizeof运算符来提供尺寸，它能自动识别操作数的类型及尺寸大小，这虽然比malloc）函数聪明不了多少，但起码使用起来会比它方便得多。当然，正如calloc（）函数，new也可以用于数组，形式如下：p = new TYPE[Size] ；对应的内存释放形式：delete [] p；同理首例中ip操作可以改版为：int * ip=new int[10]；delete [] ip；用new分配多维数组的形式为：p = new TYPE [c0] [c1]…… [cN]；从来没有太快活的事情，例如以下使用非法：int***ip2=（int***）new int[m] [n][k]； //error. Constant expression required int***ip 1=（int***）new int[m][2][81； //ok C++最多只允许数组第一维的尺寸（即c0）是个变量，而其它的都应该为确定的编译时期常量。使用new分配数组时，也不能再提供初始值：char*String =new char[ 20] （"Scent of a Woman"）； //error： Array allocated using 'new' may not have an initializer 6.引用（reference）
　　（1）函数参数引用以下例程中的Swap（）函数对数据交换毫无用处：　//test04. cpp
#include <iostream.h>
void Swap(int va int vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << " b=" <　　 b=2c语言对参数的调用采取拷贝传值方式，在实际函数体内，使用的只是与实参等值的另一份拷贝，而并非实参本身（它们所占的地址不同），这就是Swap（）忙了半天却什么好处都没捞到的原因，它改变的只是地址0x0012FF24和0x0012FF28处的值。当然，可采取似乎更先进的指针来改写以上的Swap （）函数： 　//test05. cpp
#include <iostream.h>

void Swap(int * vap int * vbp)
{
　　　　　　 int temp = *vap;
　　　　　　 *vap = *vbp;
　　　　　　 *vbp = temp;
　　　　　　 cout << "vap=" << vap

发表于 2014-10-29 15:02:16

教你从C轻松到C++(六)

<< "vbp=" <<vbp << endl;
　　　　　　 cout << "&vap=" << &vap << "&vbp=" << &vbp << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 int * ap = &a * bp = &b;
　　　　　　 cout << "ap=" << ap << "bp=" << bp << endl;
　　　　　　 cout << "&ap=" << &ap << "&bp=" << &bp << endl;
　　　　　　 Swap(ap bp);
　　　　　　 cout << "a=" << a << "b=" << b <<endl;
}
ap=0x0012FF7Cbp=0x0012FF78
&ap=0x0012FF74&bp=0x0012FF70
vap=0x0012FF7Cvbp=0x0012FF78
&vap=0x0012FF1C&vbp=0x0012FF20
a=2b=1在上例中，参数的调用仍采取的是拷贝传值方式，Swap（）拷贝一份实参的值（其中的内容即a b的地址），但这并不表明vapvbp与实参apbp占据同一内存单元。　　对实际数据操作时，传统的拷贝方式并不值得欢迎，C++为此提出了引用方式，它允许函数使用实参本身（其它一些高级语言，如BASIC FORTRAN即采取这种方式）。以下是相应的程序：　//test06. cpp
#include <iostream.h>
void Swap(int & va int & vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << "b=" << b << endl;
}

&a=0x0012FF7C&b=0x0012FF78
&va=0x0012FF7C&vb=0x0012FF78
a=2b=1
　　很明显，a b与vavb的地址完全重合。
　　对int&的写法别把眼睛瞪得太大，你顶多只能撇撇嘴，然后不动声色地说：“就这么回事！加上&就表明引用方式呗！”（2）简单变量引用简单变量引用可以为同一变量取不同的名字，以下是个例子：int Rat；int & Mouse=Rat；这样定义之后，Rat就是Mouse（用中文说就是：老鼠就是老鼠），这两个名字指向同一内存单元，如：Mouse=Mickey； //Rat=Mickey一种更浅显的理解是把引用看成伪装的指针，例如，Mouse很可能被编译器解释成：*（& Rat），这种理解可能是正确的。
　　由于引用严格来说不是对象（？！），在使用时应该注意到以下几点：①引用在声明时必须进行初始化；②不能声明引用的引用；③不能声明引用数组成指向引用的指针（但可以声明对指针的引用）；④为引用提供的初始值必须是一个变量。
　　当初始值是一个常量或是一个使用const修饰的变量，或者引用类型与变量类型不一致时，编译器则为之建立一个临时变量，然后对该临时变量进行引用。例如：　int & refl = 50; //int temp=50 &refl=temp
float a=100.0;
int & ref2 = a; / / int temp=a&ref2=temp
　　（3）函数返回引用函数可以返回一个引用。观察程序test07：　//test07.cpp
#include <iostream.h>
char &Value (char*a int index)
{
　　　　　　 return a[index];
}

void main()
{
　　　　　　 char String[20] = "a monkey!";
　　　　　　 Value(String 2) = 'd';
　　　　　　 cout << String << endl;
}

a donkey!　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 1

发表于 2014-10-29 15:02:58

教你从C轻松到C++(七)

00 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　对实际数据操作时，传统的拷贝方式并不值得欢迎，C++为此提出了引用方式，它允许函数使用实参本身（其它一些高级语言，如BASIC FORTRAN即采取这种方式）。以下是相应的程序：　//test06. cpp
#include <iostream.h>
void Swap(int & va int & vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << "b=" << b << endl;
}

&a=0x0012FF7C&b=0x0012FF78
&va=0x0012FF7C&vb=0x0012FF78
a=2b=1
　　很明显，a b与vavb的地址完全重合。
　　对int&的写法别把眼睛瞪得太大，你顶多只能撇撇嘴，然后不动声色地说：“就这么回事！加上&就表明引用方式呗！”（2）简单变量引用简单变量引用可以为同一变量取不同的名字，以下是个例子：int Rat；int & Mouse=Rat；这样定义之后，Rat就是Mouse（用中文说就是：老鼠就是老鼠），这两个名字指向同一内存单元，如：Mouse=Mickey； //Rat=Mickey一种更浅显的理解是把引用看成伪装的指针，例如，Mouse很可能被编译器解释成：*（& Rat），这种理解可能是正确的。
　　由于引用严格来说不是对象（？！），在使用时应该注意到以下几点：①引用在声明时必须进行初始化；②不能声明引用的引用；③不能声明引用数组成指向引用的指针（但可以声明对指针的引用）；④为引用提供的初始值必须是一个变量。
　　当初始值是一个常量或是一个使用const修饰的变量，或者引用类型与变量类型不一致时，编译器则为之建立一个临时变量，然后对该临时变量进行引用。例如：　int & refl = 50; //int temp=50 &refl=temp
float a=100.0;
int & ref2 = a; / / int temp=a&ref2=temp
　　（3）函数返回引用函数可以返回一个引用。观察程序test07： 　//test07.cpp
#include <iostream.h>
char &Value (char*a int index)
{
　　　　　　 return a[index];
}

void main()
{
　　　　　　 char String[20] = "a monkey!";
　　　　　　 Value(String 2) = 'd';
　　　　　　 cout << String << endl;
}

a donkey!　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default v

发表于 2014-10-29 15:03:03

教你从C轻松到C++(八)

alue）　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　即时声明常见于for循环语句中： for(int i = 0; i < 16; i++)
　　　　　　　　　　　　　 for(int j = 0; j < 16; j++)
　　　　　　　　　　　　　　　　　　　　 putpixel(j i Color[j]);
　　这种形式允许在语句段中任点声明新的变量并不失时机地使用它（而不必在所有的声明结束之后）。
　　特别地，C++强化了数据类型的类概念，对于以上出现的“int i=1 j=2；”完全可以写成：int i（1） j （2）；再如：　char * Stringl("Youth Studio.”);
char String2[]("Computer Fan.“);
　　这不属于“即时声明”的范畴，但这些特性足以让你的代码与先前愚昧的C产品区别开来。
　　 4.作用域（scope）及其存取操作符（scope qualifier operator）
　　即时声明使C语言的作用域的概念尤显重要，例如以下语句包含着一条错误，因为ch变量在if块外失去了作用域。　if(ok)
　　　　　　　　　　　　　 char ch='!';
　　　　　　 else
　　　　　　　　　　　　 ch='?'; //error. access outside condition
　　作用域对应于某一变量的生存周期，它通常表现为以下五种:
　　块作用域
　　开始于声明点，结束于块尾，块是由{}括起的一段区域
　　函数作用域
　　函数作用域只有语句标号，标号名可以和goto语句一起在函数

发表于 2014-10-29 15:04:42

教你从C轻松到C++(九)

t&的写法别把眼睛瞪得太大，你顶多只能撇撇嘴，然后不动声色地说：“就这么回事！加上&就表明引用方式呗！”（2）简单变量引用简单变量引用可以为同一变量取不同的名字，以下是个例子：int Rat；int & Mouse=Rat；这样定义之后，Rat就是Mouse（用中文说就是：老鼠就是老鼠），这两个名字指向同一内存单元，如：Mouse=Mickey； //Rat=Mickey一种更浅显的理解是把引用看成伪装的指针，例如，Mouse很可能被编译器解释成：*（& Rat），这种理解可能是正确的。　　由于引用严格来说不是对象（？！），在使用时应该注意到以下几点：①引用在声明时必须进行初始化；②不能声明引用的引用；③不能声明引用数组成指向引用的指针（但可以声明对指针的引用）；④为引用提供的初始值必须是一个变量。
　　当初始值是一个常量或是一个使用const修饰的变量，或者引用类型与变量类型不一致时，编译器则为之建立一个临时变量，然后对该临时变量进行引用。例如：　int & refl = 50; //int temp=50 &refl=temp
float a=100.0;
int & ref2 = a; / / int temp=a&ref2=temp
　　（3）函数返回引用函数可以返回一个引用。观察程序test07：　//test07.cpp
#include <iostream.h>
char &Value (char*a int index)
{
　　　　　　 return a[index];
}

void main()
{
　　　　　　 char String[20] = "a monkey!";
　　　　　　 Value(String 2) = 'd';
　　　　　　 cout << String << endl;
}

a donkey!　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。

　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED

发表于 2014-10-29 15:13:47

教你从C轻松到C++(十)

环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　这个程序利用函数返回引用写出了诸如Value （String 2） ='d‘这样令人费解的语句。在这种情况下，函数允许用在赋值运算符的左边。
　　函数返回引用也常常应用于操作符重载函数。
　　 7.缺省参数（default value）
　　从事过DOS环境下图形设计的朋友（至少我在这个陷阱里曾经摸了两年时间）肯定熟悉initgraph（）函数，它的原型为：void far initgraph（int far *GraphDriver int far*GraphMode char far*DriverPath）；也许你会为它再定做一个函数：　void InitGraph(int Driver int Mode)
{
initgraph(& Driver &Mode ““);
}
　　一段时间下来，你肯定有了你最钟情的调用方式，例如你就喜欢使用640 * 480 * 16这种工作模式。
　　既然如此，你完全可以将函数InitGraph （）声明成具有缺省的图形模式参数，如下：void InitGraph（int Driver = VGA int Mode = VGAHI）；这样，每次你只需简单地使用语句InitGraph （）；即可进入你所喜爱的那种模式。当然，当你使用InitGraph （CGA CGAHI ）；机器也会毫不犹豫地切入到指定的CGAHI模式，而与正常的函数没有两样。
　　这就是缺省参数的用法！为了提供更丰富的功能，一些函数要求用户提供更多的参数（注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册），而实际上，这些参数中的某几项常常是被固定引用的，因此，就可以将它们设定为缺省参数，例如以下函数：void Putpixel（int x int y int Color=BLACK char Mode =COPY_PUT）；将可能在（（x y）处以Color颜色、Mode模式画一个点，缺省情况下，颜色为黑色，写点模式为覆盖方式。

　　以下对函数的调用合法：Putpixel （100 100）； // Putpixel（100 100 BLACK COPY _PUT）
　　 PutPixel （100 100 RED）； // PutPixel（100 100 RED COPY_ PUT）
　　 PutPixel（100 100 RED XOR_PUT）；而以下调用形式并不合法：Putpixel（）；Putpixel （100）；Putpixel（100 100 XOR_PUT）；前两种形式缺少参数，因为x、y值并没有缺省值；第三种形式则天真地以为编译器会将其处理成：PutPixel （100 100 BLACK XOR_PUT）；并且不会产生任何二义性问题，不幸的是，C++并不赞成这样做。
　　作为一条经验，缺省参数序列中最容易改变其调用值的应尽量写在前面，最可能使用其缺省值的（即最稳定的）置于后端。如果将以上函数原型声明成如下形式：void Putpixel（int Color = BLACK char Mode = COPY_PUT int x=100 int y=100）；包括你自己，也不会喜欢它。
　　对实际数据操作时，传统的拷贝方式并不值得欢迎，C++为此提出了引用方式，它允许函数使用实参本身（其它一些高级语言，如BASIC FORTRAN即采取这种方式）。以下是相应的程序：　//test06. cpp
#include <iostream.h>
void Swap(int & va int & vb)
{
　　　　　　 int temp=va;
　　　　　　 va=vb;
　　　　　　 vb=temp;
　　　　　　 cout << "&va=" << &va << "&vb=" << &vb << endl;
}
void main()
{
　　　　　 int a(1) b(2);
　　　　　　 cout << "&a=" << &a << "&b=" << &b << endl;
　　　　　　 Swap(a b);
　　　　　　 cout << "a=" << a << "b=" <　　对in

帐号		自动登录	找回密码
密码			中文注册

[电脑编程] 教你从C轻松到C++(一)

教你从C轻松到C++(二)

教你从C轻松到C++(三)

教你从C轻松到C++(四)

教你从C轻松到C++(五)

教你从C轻松到C++(六)

教你从C轻松到C++(七)

教你从C轻松到C++(八)

教你从C轻松到C++(九)

教你从C轻松到C++(十)