【ctoc模式什么意思】CtoC++新手指南

【shitiku.jxxyjl.com--软件水平学习指南】

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[i][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所属的性别。更妙的是，::之前还可以加上某些类的名称，它表示引用的变量是该类的成员。

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 =&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=0x0012ff24&vb=0x0012ff28
a=1

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=" << 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 y inint xt 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);

包括你自己，也不会喜欢它。

本文来源：https://shitiku.jxxyjl.com/ruanjianshuipingxuexizhinan/49047.html