C++.docx

C++.docx

《C++.docx》由会员分享，可在线阅读，更多相关《C++.docx（61页珍藏版）》请在冰豆网上搜索。

C++

1.最简单的C++程序:

a.#include

intmain（）

{

intx;

std:

:

cin>>x;//从控制台输入x的值

std:

:

cout<

return0;

}

b.#include

usingstd:

:

cout;

usingstd:

:

endl;//声明即将使用std中的cout和endl函数

intmain（）

{

cout<<"五年级一班数学成绩表\n";

cout<<"首先是第一名许凡的成绩：

\t"<<100;//先输出字符串,再输出数字100,\t相当于Tab键

cout<

cout<<"其次是第二名张友的成绩：

\t"<<90+9;

cout<

cout<<"最后是末一名林杰的成绩：

\t"<<（float）5/8;

cout<

return0;

}

程序b也可改为:

#include

intmain（）

{

cout<<"五年级一班数学成绩表\n";

cout<<"首先是第一名许凡的成绩：

\t"<<100;

cout<

cout<<"其次是第二名张友的成绩：

\t"<<90+9;

cout<

cout<<"最后是末一名林杰的成绩：

\t"<<（float）5/8;

cout<

return0;

}

还可改为：

#include

usingnamespacestd;

intmain（）

{

cout<<"五年级一班数学成绩表\n";

cout<<"首先是第一名许凡的成绩：

\t"<<100;

cout<

cout<<"其次是第一名张友的成绩：

\t"<<90+9;

cout<

cout<<"最后是末一名林杰的成绩：

\t"<<（float）5/8;

cout<

return0;

}

2.名字空间（namespace）的作用:

#include

namespacea

{

intb=5;

}

namespacec

{

intb=8;

}

intmain（）

{

intb=9;

std:

:

cout<

:

b<<""<

:

b<

:

endl;//依次打印三个b的值

return0;

}

程序改为:

#include

namespacea

{

intb=5;

}

namespacec

{

intb=8;

}

intmain（）

{

usingnamespacea;

usingnamespacec;

std:

:

cout<

return0;

}

编译出错,b引起歧义

若改为:

#include

namespacea

{

intb=5;

}

namespacec

{

intb=8;

}

intmain（）

{

usingnamespacea;

usingnamespacec;

intb=9;

std:

:

cout<

return0;

}

打印的结果是9

3.C++有六种数据类型:

布尔型（bool）、字符型（char）、双字符型（wchar_t）、整型（int）、单精度浮点型（float）、双精度浮点型（double）

4.ASCII码:

在ASCII码表中,十进制数48-57为0-9十个阿拉伯数字、65-90为26个大写英文字母、97-122为26个小写英文字母

5.C++中类的大小等于该类中的成员变量所占字节数的总和;C++中默认的成员变量的访问控制修饰符是private,若在main函数中要访问一个类中的私有成员变量,就要在该类中设置一个公有的接口函数,类的对象通过这个接口函数才能访问私有成员;一般情况下,我们都将类的成员变量设置为私有，而使用类的公有函数来访问他们,这样的好处是数据的赋值与读取分开操作,赋值函数不需要考虑读取函数是如何工作的,读取函数中代码的改变也不会影响到赋值函数。

如:

#include

usingstd:

:

cout;

classHuman

{

public:

voidset（intw）

{

if（w>0&&w<100）

{

weight=w;

}

else

{

cout<<"请将set函数的参数设置为一个大于0而小于100的数字，否则默认返回0\n";

weight=0;

}

}

intprint（）{returnweight;}

private:

intweight;

};

intmain（）

{

HumanTom;

Tom.set（-1）;

cout<<"汤姆的体重为：

"<

HumanMike;

Mike.set（101）;

cout<<"迈克的体重为：

"<

return0;

}

6.一般来说当我们定义了一个函数后,编译器就会在内存中为其创建一个指令集,当我们调用这个函数时,程序就会跳转到该指令集处,当函数执行完毕后,程序又会返回到原来执行调用函数的下一行继续执行,假如对该函数执行了上百次调用,那么就要来回跳转上百次,很明显这是相当影响程序执行效率的,C++对此有种解决办法,即使用关键字inline声明内联函数,即:

"inlineintprint（）;intprint（）{...}",使用内联函数后,编译器将不会创建真正的函数,而只是将这个内联函数的所有代码拷到调用函数中,这样程序在执行调用该函数时就不需要来回跳转,自然就会提高了程序运行时的效率,但使用内联函数也有负面影响,当调用内联函数上百次时,就需要复制上百次代码,当然我们也有折衷的选择,假如函数很小的话,那么即使多次复制也不会增加多少体积,这时使用内联函数还是相当划算的.

7.将类的声明和定义存放在一个名为"*.h"的头文件中,将程序的执行部分放在另一个名为"*.cpp"的源文件中,在"*.cpp"文件的顶端用"#include"*.h""引入头文件,由于在头文件的开头已经用了"#include",所以在源文件中不需要在引用这句程序

8.如果你不想让某个成员函数修改成员变量的值,那么不妨将这个成员函数声明为const,如:

voidfunc（）const{...},在编程时一定要尽量多用const,对于不应当改变对象的成员函数都应该声明为const,这样假如该成员函数试图去修改该对象的成员变量,编译器会提示错误,从而达到帮助你查错的目的

9.析构函数与构造函数相反,构造函数用于构造一个对象,析构函数则用于在对象被销毁后清除它所占用的内存空间,比如说它可以清除由构造函数创建的内存,析构函数的函数名和构造函数的函数名相同,析构函数的定义只是比构造函数多了一个波浪纹（~）并且不能有参数,一个类有且只有一个析构函数,如:

#include

usingnamespacestd;

classA

{

public:

A（）{cout<<"构造函数执行完毕！

\n";}

~A（）{cout<<"析构函数执行完毕！

\n";}

};

intmain（）

{

Aa;

return0;

}

由于每个对象在创建时都会自动调用该类的构造函数,所以程序运行时打印出第一句"构造函数执行完毕！

",右大括号表示整个程序结束,对象a的生命也自然终止,这时编译器会自动调用该类的析构函数来释放掉该对象所占的内存,因此程序输出"析构函数执行完毕！

".上面的程序也可写成:

#include

usingnamespacestd;

classA

{

public:

A（）;

~A（）;

};

A:

:

A（）{cout<<"构造函数执行完毕！

\n";}

A:

:

~A（）{cout<<"析构函数执行完毕！

\n";}

intmain（）

{

Aa;

return0;

}

再如以下程序:

#include

usingnamespacestd;

classA

{

public:

A（）;

~A（）;

};

A:

:

A（）{cout<<"构造函数执行完毕！

\n";}

A:

:

~A（）{cout<<"析构函数执行完毕！

\n";}

intmain（）

{

Aa[2];

return0;

}

程序执行结果:

构造函数执行完毕！

构造函数执行完毕！

析构函数执行完毕！

析构函数执行完毕！

又有以下程序:

#include

usingnamespacestd;

classA

{

public:

A（）;

~A（）;

};

A:

:

A（）{cout<<"构造函数执行完毕！

\n";}

A:

:

~A（）{cout<<"析构函数执行完毕！

\n";}

intmain（）

{

A*p;

return0;

}

程序执行时,没有输出任何信息,这是因为在栈内存中创建指针对象时不调用构造方法,因此也就不调用析构方法.注意:

只要调用了构造方法构造对象,就必须调用析构方法来析构对象

如果是以下程序:

#include

usingnamespacestd;

classA

{

public:

A（）;

~A（）;

};

A:

:

A（）{cout<<"构造函数执行完毕！

\n";}

A:

:

~A（）{cout<<"析构函数执行完毕！

\n";}

intmain（）

{

A*p=newA;//在堆中创建了一个A类大小的内存

deletep;

return0;

}

程序执行结果:

构造函数执行完毕！

析构函数执行完毕！

在堆内存中创建对象时,会调用构造方法,如果在堆内存中是这样创建"A*p=newA

（1）",则调用的是有一个参数的构造方法

10.逻辑非运算符

#include

usingnamespacestd;

intmain（）

{

intx;

cout<<"请输入一个大于1的整数：

\n";

cin>>x;

if（!

x==0）

cout<<"x不等于0\n";

else

cout<<"x等于0\n";

return0;

}

程序的if条件"!

x==0"表示"x==0"是假的,所以当输入一个0的数时,程序执行else分支

10.真假关系

#include

usingnamespacestd;

intmain（）

{

chara='A';

if（a）

{

a='a';

cout<

}

else

{

a='A';

cout<

}

}

程序的运行结果是:

a,这说明变量a返回了一个真值,也就是1,因为数字、符号、字母在计算机看来是一个真值,所以字母a是一个真值.如果程序改为:

#include

usingnamespacestd;

intmain（）

{

chara='\0';

if（a）

{

a='a';

cout<

}

else

{

a='A';

cout<

}

}

程序的运行结果是:

A,因为字母a为空值,所以if的条件句为假,程序执行else分支.如果程序改为:

#include

usingnamespacestd;

intmain（）

{

chara='\0';

if（!

a）

{

cout<<"a的值为0"<

}

else

{

cout<<"a的值为1"<

}

}

程序的运行结果是:

a的值为0,这是因为a为空时,!

a表示非空,if语句的条件为真,执行if语句

11.三目运算符:

inta=1,b=2,z;z=a>b?

a:

a>b?

a:

b;z的值是2,双重三目运算符的执行顺序是从右到左;若三目运算符中的变量的数据类型不一致,系统会将数据类型级别较低的转换成级别较高的,然后再进行求值操作,如:

inta=1;floatb=2.1f;cout<<（a>b?

a:

b）;本程序在执行到三目运算符时,先把int型的a转换成float型

12.引用即取别名,定义引用时一定要在定义的时候进行初始化.如下程序:

#include

usingnamespacestd;

intmain（）

{

inta,b;

int&ra=a;

a=999;

b=888;

ra=b;

ra=1;

}

程序"&ra=a"中的"&"是引用运算符,这句执行完之后,系统把a的地址赋给了ra,所以执行到a=999时,ra的值也变成了999,此时如果打印a和ra的地址,则这两个地址的值时一样的,把b的值赋给ra之后ra的地址并没有改变,仍然和a的地址一样,只是ra和a的值变成了888,b仍然是它自己的地址没有改变,所以当程序执行ra=1时,a的值也变成了1,b的值不会改变.也可以定义对象的别名:

#include

usingnamespacestd;

classHuman

{

public:

intget（）{returni;}

voidset（intx）{i=x;}

private:

inti;

};

intmain（）

{

HumanMike;

Human&rMike=Mike;

rMike.set（123）;

cout<

return0;

}

按别名传递参数进行两数的交换:

#include

usingnamespacestd;

voidswap（int&a,int&b）

{

intc;

cout<<"swap函数中，交换前，a:

"<

"<

c=a;

a=b;

b=c;

cout<<"swap函数中，交换后，a:

"<

"<

}

intmain（）

{

inta=3,b=4;

cout<<"主程序中，交换前，a:

"<

"<

swap（a,b）;

cout<<"主程序中，交换后，a:

"<

"<

return0;

}

13.按值传递和函数返回一个值时,系统自动调用复制构造函数:

#include

usingnamespacestd;

classA

{

public:

A（）{cout<<"执行构造函数创建一个对象\n";}

A（A&）{cout<<"执行复制构造函数创建该对象的副本\n";}

~A（）{cout<<"执行析构函数删除该对象\n";}

};

Afunc（Aone）

{

returnone;

}

intmain（）

{

Aa;

func（a）;

return0;

}

程序的执行结果是:

执行构造函数创建一个对象

执行复制构造函数创建该对象的副本

执行复制构造函数创建该对象的副本

执行析构函数删除该对象

执行析构函数删除该对象

执行析构函数删除该对象

这是因为:

从主函数开始,创建一个对象a时,系统自动调用构造函数,打印"执行构造函数创建一个对象";调用函数func（a）把a的值传递过去,这是系统会自动调用复制构造函数,打印"执行复制构造函数创建该对象的副本";当func（）函数执行完毕,返回一个值时,系统再次调用复制构造函数,打印"执行复制构造函数创建该对象的副本";用于func（）函数的返回值没有被接收,返回值被丢弃,并且该返回值是一个对象,所以系统自动调用析构函数释放该对象所占的内存,打印"执行析构函数删除该对象";func（）函数执行完毕,系统会自动调用析构函数释放该函数的参数中定义的对象,打印"执行析构函数删除该对象";func（）函数执行完毕后,回到主函数,在主函数即将结束前的那一秒,系统再次调用析构函数,释放a对象所占的内存空间,打印"执行析构函数删除该对象".如果是按址传递:

#include

usingnamespacestd;

classA

{

public:

A（）{cout<<"执行构造函数创建一个对象\n";}

A（A&）{cout<<"执行复制构造函数创建该对象的副本\n";}

~A（）{cout<<"执行析构函数删除该对象\n";}

};

Afunc（A*one）

{

return*one;

}

intmain（）

{

Aa;

func（&a）;

return0;

}

程序的执行结果是:

执行构造函数创建一个对象

执行复制构造函数创建该对象的副本

执行析构函数删除该对象

执行析构函数删除该对象

这是因为:

从主函数开始,创建一个对象a时,系统自动调用构造函数,打印"执行构造函数创建一个对象";调用函数func（&a）把a的地址传递过去,这时系统不会调用复制构造函数,所以不打印"执行复制构造函数创建该对象的副本";当func（）函数执行完毕,返回一个值时,系统自动调用复制构造函数,打印"执行复制构造函数创建该对象的副本";用于func（）函数的返回值没有被接收,返回值被丢弃,并且该返回值是一个对象,所以系统自动调用析构函数释放该对象所占的内存,打印"执行析构函数删除该对象";func（）函数执行完毕后,回到主函数,在主函数即将结束前的那一秒,系统再次调用析构函数,释放a对象所占的内存空间,打印"执行析构函数删除该对象".如果是按地址传递并且返回地址:

#include

usingnamespacestd;

classA

{

public:

A（）{cout<<"执行构造函数创建一个对象\n";}

A（A&）{cout<<"执行复制构造函数创建该对象的副本\n";}

~A（）{cout<<"执行析构函数删除该对象\n";}

};

A*func（A*one）

{

returnone;

}

intmain（）

{

Aa;

func（&a）;

return0;

}

程序的执行结果是:

执行构造函数创建一个对象

执行析构函数删除该对象

这是因为:

从主函数开始,创建一个对象a时,系统自动调用构造函数,打印"执行构造函数创建一个对象";在主函数即将结束前的那一秒,系统调用析构函数,释放a对象所占的内存空间,打印"执行析构函数删除该对象".

按别名来传递对象：

classA

{

public:

A（）{cout<<"执行构造函数创建一个对象\n";}

A（A&）{cout<<"执行复制构造函数创建该对象的副本\n";}

~A（）{cout<<"执行析构函数删除该对象\n";}

voidset（inti）{x=i;}

intget（）const{returnx;}

private:

intx;

};

A&func（A&one）

{

returnone;

}

intmain（）

{

Aa;

a.set（11）;

A&b=func（a）;

cout<

return0;

}

程序的执行结果是:

执行构造函数创建一个对象

11

执行析构函数删除该对象

按别名来传递对象不调用复制构造函数

程序改为:

classA

{

public:

A（）{cout<<"执行构造函数创建一个对象\n";}

A（A&）{cout<<"执行复制构造函数创建该对象的副本\n";}

~A（）{cout<<"执行析构函数删除该对象\n";}

voidset（inti）{x=i;}

intget（）const{returnx;}

private:

intx;

};

A&func（A&one）

{

returnone;

}

intmain（）

{

Aa;

a.set（11）;

A&b=func（a）;

cout<

b.set（33）;

cout<

return0;

}

程序的执行结果是:

执行构造函数创建一个对象

11

33

执行析构函数删除该对象

若程序改为：

classA

{

public:

A（）{cout<<"执行构造函数创建一个对象\n";}

A（A&）{cout<<"执行复制构造函数创建该对象的副本\n";}

~A（）{cout<<"执行析构函数删除该对象\n";}

voidset（inti）{x=i;}

intget（）const{returnx;}

private:

intx;

};

constA&func（A&one）

{

returnone;

}

intmain（）

{

Aa;

a.set（11）;

constA&b=func（a）;

cout<

//b.set（33）;//执行这条语句会报错,因为b是一个常量的对象的别名

return0;

}

14.栈区（stack）由编译器自动分配并且释放,该区域一般存放函数的参数值、局部变量的值、局部对象的值和引用等,并且该区中的数据的寿命是到方法结束返回时;堆区（heap）用于存放引用类型和基本数据类型new出来的内存,该内存由程序员分配并且释放,若程序员不释放,要等到程序结束后操作系统才回收,堆是采用匿名的方式来保存数据的,只有通过指针才能访问到这些匿名的数据,自由度最高、安全性最好;寄存器区用来保存栈顶指针和指令指针;全局区又称静态区（static）,在静态区中存放的是全局变量和静态变量,初始化的全局变量和静态变量在一块区域,未初始化的全局变量和静态变量在相邻的令一块区域,程序结束后静态区由系统释放;文字常量区用于存放常量字符串,程序结束后由系统释放;程序代码区存放函数体的二进制代码.（静态方法中不能引用非静态成员,且在该方法中不能使用this关键字）

15.创建一个堆:

int