经验分享 从C到C++(一)

开发 后端
本文介绍的是从C到C++我们应该学习哪些内容,让你轻轻松松完成从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:

  1. //test01.cpp  
  2. #include <iostream.h>  
  3. //I'm a C++user!  
  4. //…and C is out of date.  
  5. void main()  
  6. {  
  7. cout<<"Hello world!\n"//prints a string  
  8. }  
  9. Hello-world! 

如果你尝试着在test0l. exe中找到这些高级的注释,很简单,它们不会在那里的。

2. cincout

你可能从test0l中嗅出什么味儿来了,在C++中,其次的贵族是cout,而不是很老土的printf ( )。左移操作符‘<<’的含义被重写,称作“输出操作符”或“插入操作符”。你可以使用‘<<’将一大堆的数据像糖葫芦一样串起来,然后再用cout输出:

  1. cout << "ASCII code of "<< 'a' << " is:" <<97;   
  2. ASCII code of a is:97  

如何来输出一个地址的值呢?在C中可以通过格式控制符”%p”来实现,如:

  1. printf ("%p,&i); 

类似地,C++也是这样:

  1. cout << & i; 

但对字符串就不同啦!因为:

  1. char * String="Waterloo Bridge";  
  2. cout << String; //prints ‘Waterloo Bridge' 

只会输出String的内容。但方法还是有的,如采取强制类型转换:

  1. cout<<(void *)String; 

cin采取的操作符是’>>’,称作“输入操作符”或“提取操作符”。在头文件iostream.h中有cin cout的原型定义,cin语句的书写格式与cout的完全一样:

  1. cin>>i; //ok  
  2. cin>>&i; //error. Illegal structure operation 

看到了?别再傻傻地送一个scanf()常用的’&’地址符给它。

C++另外提供了一个操纵算子endl,它的功能和’\n’完全一样,如test0l中的cout语句可改版为:

  1. cout << ”Hello world!”< 

#p#

3.即时声明

这是笔者杜撰的一个术语,它的原文为declarations mixed with statements,意即允许变量的声明与语句的混合使用。传统C程序提倡用户将声明和语句分开,如下形式:

  1. int i=100;  
  2. float f; //declarations   
  3. i++;  
  4. f=1.0/i; //statements  

而C抛弃这点可读性,允许用户采取更自由的书写形式:

  1. int i=100;  
  2. i++;  
  3. float f =1. 0/i;  

即时声明常见于for循环语句中:

  1. for(int i = 0; i < 16; i++)  
  2. for(int j = 0; j < 16; j++)  
  3. putpixel(j i Color[i][j]);  

这种形式允许在语句段中任点声明新的变量并不失时机地使用它(而不必在所有的声明结束之后)。

特别地,C++强化了数据类型的类概念,对于以上出现的“int i=1 j=2;”完全可以写成:int i(1) j (2);再如:

  1. char * Stringl("Youth Studio.”);  
  2. char String2[]("Computer Fan.“);  

 这不属于“即时声明”的范畴,但这些特性足以让你的代码与先前愚昧的C产品区别开来。

4.作用域(scope)及其存取操作符(scope qualifier operator)

即时声明使C语言的作用域的概念尤显重要,例如以下语句包含着一条错误,因为ch变量在if块外失去了作用域。

  1. if(ok)  
  2. char ch='!';  
  3. else 
  4. ch='?'//error. access outside condition  
  • 作用域对应于某一变量的生存周期,它通常表现为以下五种:
  • 块作用域:开始于声明点,结束于块尾,块是由{}括起的一段区域
  • 函数作用域:函数作用域只有语句标号,标号名可以和goto语句一起在函数体任何地方
  • 函数原型作用域:在函数原型中的参量说明表中声明的标识符具有函数原型作用域
  • 文件作用域:在所有块和类的外部声明的标识符(全局变量)具有文件作用域
  • 类作用域:类的成员具有类作用域

具有不同作用域的变量可以同名,如test02:

  1. //test02.cpp  
  2. #include <iostream.h>  
  3. int i=0;  
  4. void main()  
  5. {  
  6. cout << i << ' '//global 'int i' visible  
  7. {  
  8. float i(0.01); //global 'int i' overrided  
  9. cout<< i << ' ';  
  10. }  
  11. cout<<i<<endl; //global 'int i' visible again  
  12. }  
  13. //输出结果 0 0.01 0   

编译器并未给出错误信息。

作用域与可见性并不是同一概念,具有作用域不一定具有可见性,而具有可见性一定具有作用域。

在test02中,float i的使用使全局int i失去可见性,这种情形被称作隐藏(override)。但这并不意味着int i失去了作用域,在main()函数运行过程中,int i始终存在。

有一种办法来引用这丢了名份的全局i,即使用C++提供的作用域存取操作符::,它表示引用的变量具有文件作用域,如下例程:

  1. //test03.cpp  
  2. #include <iostream.h>  
  3. enum {boy girl};  
  4. char i = boy;  
  5. void main()  
  6. {  
  7. {  
  8. float i(0.01);  
  9. cout << "i=" << i << endl;  
  10. ::i=girl; //modify global 'i'  
  11. }  
  12. cout << "I am a " << (i ? "girl." : "boy.");  
  13. }  
  14. 输出结果:  
  15. i=0.01  
  16. I am a girl. 

在上例中,通过::操作符,第8行语句偷偷地改写了i所属的性别。更妙的是,::之前还可以加上某些类的名称,它表示引用的变量是该类的成员。

#p#

5. new delete

许多C用户肯定不会忘记alloc()和free()函数族,它们曾经为动态内存分配与释放的操作做出了很大的贡献,如:

  1. char *cp = malloc(sizeof(char));  
  2. int *ip=calloc(sizeof(int) 10);  
  3. free(ip);  
  4. free(cp);  

C++允许用户使用这些函数,但它同时也提供了两个类似的操作符new和delete,它们分别用来分配和释放内存,形式如下:

  1. p = new TYPE;  
  2. delete p; 

因此以上的cp操作可改版为:

  1. char*cp=new char;  
  2. delete cp; 

new delete操作符同样亦可作用于C中的结构变量,如:

  1. struct COMPLEX*cp = new struct COMPLEX;  
  2. delete cp; 

当不能成功地分配所需要的内存时,new将返回NULL.对于字符型变量可以如下初始化:

  1. char ch('A'); //char ch='A' 

对应地,new可以同时对变量的值进行初始化,如:

  1. char p=new char ('A‘); //cp='A' new 

不需要用户再使用sizeof运算符来提供尺寸,它能自动识别操作数的类型及尺寸大小,这虽然比malloc)函数聪明不了多少,但起码使用起来会比它方便得多。当然,正如calloc()函数,new也可以用于数组,形式如下:

  1. p = new TYPE[Size] ; 

对应的内存释放形式:

  1. delete [] p; 

同理首例中ip操作可以改版为:

  1. int * ip=new int[10];  
  2. delete [] ip; 

用new分配多维数组的形式为:

  1. p = new TYPE [c0] [c1]…… [cN]; 

从来没有太快活的事情,例如以下使用非法:

  1. int***ip2=(int***)new int[m] [n][k]; 
  2. //error. Constant expression required int***ip 1=(int***)new int[m][2][81; //ok  

C++最多只允许数组***维的尺寸(即c0)是个变量,而其它的都应该为确定的编译时期常量。使用new分配数组时,也不能再提供初始值:

  1. char*String =new char[ 20] ("Scent of a Woman");   
  2. //error: Array allocated using 'new' may not have an initializer  

#p#

6.引用(reference)

(1)函数参数引用以下例程中的Swap()函数对数据交换毫无用处:

  1. //test04. cpp  
  2. #include <iostream.h>  
  3. void Swap(int va int vb)  
  4. {  
  5. int temp=va;  
  6. va=vb;  
  7. vb=temp;  
  8. cout << "&va=" << &va << "&vb=" << &vb << endl;  
  9. }  
  10. void main()  
  11. {  
  12. int a(1) b(2);  
  13. cout << "&a=" << &a << "&b=" << &b << endl;  
  14. Swap(a b);  
  15. cout << "a=" << a << " b=" << b << endl;  

输出结果:

  1. &a=0x0012FF7C&b=0x0012FF78 
  2. &va=0x0012FF24&vb=0x0012FF28 
  3. a=1 
  4. b=2c 

语言对参数的调用采取拷贝传值方式,在实际函数体内,使用的只是与实参等值的另一份拷贝,而并非实参本身(它们所占的地址不同),这就是Swap()忙了半天却什么好处都没捞到的原因,它改变的只是地址0x0012FF24和0x0012FF28处的值。当然,可采取似乎更先进的指针来改写以上的Swap ()函数:

  1. //test05. cpp  
  2. #include <iostream.h>  
  3. void Swap(int * vap int * vbp)  
  4. {  
  5. int temp = *vap;  
  6. *vap = *vbp;  
  7. *vbp = temp;  
  8. cout << "vap=" << vap << "vbp=" <<vbp << endl;  
  9. cout << "&vap=" << &vap << "&vbp=" << &vbp << endl;  
  10. }  
  11. void main()  
  12. {  
  13. int a(1) b(2);  
  14. int * ap = &a * bp = &b;  
  15. cout << "ap=" << ap << "bp=" << bp << endl;  
  16. cout << "&ap=" << &ap << "&bp=" << &bp << endl;  
  17. Swap(ap bp);  
  18. cout << "a=" << a << "b=" << b <<endl;  
  19. }  
  20. ap=0x0012FF7Cbp=0x0012FF78  
  21. &ap=0x0012FF74&bp=0x0012FF70  
  22. vap=0x0012FF7Cvbp=0x0012FF78  
  23. &vap=0x0012FF1C&vbp=0x0012FF20  
  24. a=2b=1 

在上例中,参数的调用仍采取的是拷贝传值方式,Swap()拷贝一份实参的值(其中的内容即a b的地址),但这并不表明vapvbp与实参apbp占据同一内存单元。

对实际数据操作时,传统的拷贝方式并不值得欢迎,C++为此提出了引用方式,它允许函数使用实参本身(其它一些高级语言,如BASIC FORTRAN即采取这种方式)。以下是相应的程序:

  1. //test06. cpp  
  2. #include <iostream.h>  
  3. void Swap(int & va int & vb)  
  4. {  
  5. int temp=va;  
  6. va=vb;  
  7. vb=temp;  
  8. cout << "&va=" << &va << "&vb=" << &vb << endl;  
  9. }  
  10. void main()  
  11. {  
  12. int a(1) b(2);  
  13. cout << "&a=" << &a << "&b=" << &b << endl;  
  14. Swap(a b);  
  15. cout << "a=" << a << "b=" << b << endl;  

输出结果:

  1. &a=0x0012FF7C&b=0x0012FF78  
  2. &va=0x0012FF7C&vb=0x0012FF78  
  3. a=2b=1 

很明显,a b与vavb的地址完全重合。对int&的写法别把眼睛瞪得太大,你顶多只能撇撇嘴,然后不动声色地说:“就这么回事!加上&就表明引用方式呗!”

(2)简单变量引用简单变量引用可以为同一变量取不同的名字,以下是个例子:

  1. int Rat;int & Mouse=Rat; 

这样定义之后,Rat就是Mouse(用中文说就是:老鼠就是老鼠),这两个名字指向同一内存单元,如:

  1. Mouse=Mickey; //Rat=Mickey 

一种更浅显的理解是把引用看成伪装的指针,例如,Mouse很可能被编译器解释成:*(& Rat),这种理解可能是正确的。

由于引用严格来说不是对象(?!),在使用时应该注意到以下几点:

①引用在声明时必须进行初始化;

②不能声明引用的引用;

③不能声明引用数组成指向引用的指针(但可以声明对指针的引用);

④为引用提供的初始值必须是一个变量。

当初始值是一个常量或是一个使用const修饰的变量,或者引用类型与变量类型不一致时,编译器则为之建立一个临时变量,然后对该临时变量进行引用。例如:

  1. int & refl = 50; //int temp=50 &refl=temp  
  2. float a=100.0;  
  3. int & ref2 = a; / / int temp=a&ref2=temp  

 (3)函数返回引用函数可以返回一个引用。观察程序test07:

  1. //test07.cpp  
  2. #include <iostream.h>  
  3. char &Value (char*a int index)  
  4. {  
  5. return a[index];  
  6. }  
  7. void main()  
  8. {  
  9. char String[20] = "a monkey!";  
  10. Value(String 2) = 'd';  
  11. cout << String << endl;  
  12. }  
  13. 输出结果:a donkey! 

这个程序利用函数返回引用写出了诸如Value (String 2) ='d‘这样令人费解的语句。在这种情况下,函数允许用在赋值运算符的左边。

函数返回引用也常常应用于操作符重载函数。

7.缺省参数(default value)

从事过DOS环境下图形设计的朋友(至少我在这个陷阱里曾经摸了两年时间)肯定熟悉initgraph()函数,它的原型为:void far initgraph(int far *GraphDriver int far*GraphMode char far*DriverPath);也许你会为它再定做一个函数:

  1. void InitGraph(int Driver int Mode)  
  2. {  
  3. initgraph(& Driver &Mode ““);  
  4. }  

一段时间下来,你肯定有了你最钟情的调用方式,例如你就喜欢使用640 * 480 * 16这种工作模式。

既然如此,你完全可以将函数InitGraph ( )声明成具有缺省的图形模式参数,如下:

  1. void InitGraph(int Driver = VGA int Mode = VGAHI); 

这样,每次你只需简单地使用语句

  1. InitGraph (); 

即可进入你所喜爱的那种模式。当然,当你使用

  1. InitGraph (CGA CGAHI ); 

机器也会毫不犹豫地切入到指定的CGAHI模式,而与正常的函数没有两样。

这就是缺省参数的用法!为了提供更丰富的功能,一些函数要求用户提供更多的参数(注意到许多Windows程序员的烟灰缸旁边都有一本很厚很厚的Windows函数接口手册),而实际上,这些参数中的某几项常常是被固定引用的,因此,就可以将它们设定为缺省参数,例如以下函数:

  1. void Putpixel(int x int y int Color=BLACK char Mode =COPY_PUT); 

将可能在((x y)处以Color颜色、Mode模式画一个点,缺省情况下,颜色为黑色,写点模式为覆盖方式。

以下对函数的调用合法:

  1. Putpixel (100 100); // Putpixel(100 100 BLACK COPY _PUT)  
  2. PutPixel (100 100 RED); // PutPixel(100 100 RED COPY_ PUT)  
  3. PutPixel(100 100 RED XOR_PUT); 

而以下调用形式并不合法:

  1. Putpixel();  
  2. Putpixel (100) ;  
  3. Putpixel(100 100 XOR_PUT); 

前两种形式缺少参数,因为x、y值并没有缺省值;第三种形式则天真地以为编译器会将其处理成:

  1. PutPixel (100 100 BLACK XOR_PUT); 

并且不会产生任何二义性问题,不幸的是,C++并不赞成这样做。

作为一条经验,缺省参数序列中最容易改变其调用值的应尽量写在前面,最可能使用其缺省值的(即最稳定的)置于后端。如果将以上函数原型声明成如下形式:

  1. void Putpixel(int Color = BLACK char Mode = COPY_PUT int x=100 int y=100); 

包括你自己,也不会喜欢它。请继续看下一篇>>

责任编辑:于铁 来源: 互联网
相关推荐

2011-07-13 17:42:32

CC++

2011-07-13 16:48:55

CC++

2011-07-13 16:36:11

C++

2010-02-04 15:19:38

C++获取CPU信息

2021-12-06 23:00:36

CC++编程语言

2015-06-25 11:21:33

C++Objective-C

2011-06-15 15:29:25

Qt C++

2009-08-27 16:03:31

从c#到c++

2009-08-20 15:54:48

从C#到C++

2010-02-05 18:09:28

C++ Doxygen

2010-02-01 11:13:00

C++ Traits

2010-01-21 16:08:26

C++语言

2024-01-22 11:33:17

C++编程语言开发

2011-07-12 13:41:15

C++

2024-11-11 09:39:11

Cloudflare迁移Go

2009-09-04 17:34:11

C#CC++

2010-02-06 13:47:08

C++标准扩展

2010-02-03 13:22:07

C++时间

2011-07-20 10:30:29

C语言

2010-01-28 16:58:32

学习C++感想
点赞
收藏

51CTO技术栈公众号