第2章 C++概述知识总结

C++概述

一、C++的起源和特点

1. C++的起源

（1）1980年贝尔实验室 Bjanre Stroustrup (比雅尼斯特劳斯特鲁普)对C改进与扩充最初称为“带类的C”，(c with classes)
（2）1983年正式命名为C++
（3）3次修订后
（4）1994年制定了ANSI c++草案
（5）1998年11月， ISO标准被批准

2. C++语言的特点

（1）C++是C的超集，C++保持与C的兼容。
（2）C++保持了C的简洁、高效和接近汇编语言等特点。用C++编写的程序比C更安全，可读性更好，代码结构更合理。
（3）增加了面向对象的机制
①抽象数据类型
②封装与信息隐蔽
③以继承方式实现程序的重用
④以函数重载、运算符重载和虚函数实现多态性
⑤以模板来实现类型的参数化

二、C++源程序的构成

1. 简单的C++程序

//sum.cpp
#include<iostream>	//编译预处理命令
using namespace std;	//使用命令空间std
int main()	//主函数首部
{
	int x,y,sum;	//定义3个整型变量
	cout<<"Please input two integers:"<<'\n';	//提示用户由键盘输入两个整数
	cin>>x;		//从键盘输入变量x的值
	cin>>y;		//从键盘输入变量y的值
	sum=x+y;	//将x+y的值赋给整型变量sum
	cout<<"x+y="<<sum<<endl;	//输出两个整数的和sum
	return 0;	//如程序正常结束，向操作系统返回一个数值0
}

2. C++程序的结构特性

（1）一个面向对象的C++程序一般由类的声明和类的使用两大部分组成。
（2）类的使用部分一般由主函数及有关子函数组成。

3. C++程序的编辑、编译、连接和运行

Visual C++6.0

三、C++在非面向对象方面的扩充

1. 注释行

(1)"/……/"
(2)"//……到行尾结束"

说明：
（1）以“//”开始的内容只在本行起作用。当注释内容为多行时，通常用/……/方式。
（2）“/……/”方式的注释不能嵌套，但它可以嵌套“//”方式的注释。

2. C++的输入输出

（1） C++可以使用函数 scanf 和 printf 进行输入输出，还增加标准输入流对象 cin 和 标准输出流对象cout来进行输入和输出。
（2）cin>>a>>b>>c;
（3）cout<<a+b<<c;

说明：
（1）使用cin或cout进行I/O操作时，在程序中必须嵌入头文件iostream。
（2）输入或输出时，cin和>>、cout和<<要配套使用。
（3）使用“cin>>”可以连续输入多个数据。
（4）可以对输入和输出格式进行控制。例如可用不同进制的方式显示数据，要用设置转换基数的操作符dec、hex和oct。其中dec把转换基数设置为十进制，hex把转换基数设置为十六进制，oct把转换基数设置为八进制，默认的转换基数是十进制。
（5）C++中增加换行操作符endl，其作用同’\n’。

3. 灵活的局部变量说明

C++允许变量声明与可执行语句在程序中交替出现。

4. 结构名、联合名和枚举名可直接作为类型名

在定义变量时，不必在结构名、联合名或枚举名前冠以struct、union或enum，例如:

enum Bool{FALSE,TRUE};
struct String{
	char * ptr;
	int length;
};

在定义变量时，可以说明为：

Bool done;		//不必在枚举名前冠以关键字enum
String str;		//不必在结构名前冠以关键字struct

但是在传统的C语言中，必须写成：

enum Bool done;
struct String str;

5. const 修饰符

C++提供了一种更灵活、更安全的方式来定义常量，即使用const修饰符来定义常量，例如：
const int LIMIT=100;
这个常量LIMIT是有类型的，占用存储单元，有地址，可以用指针指向它，但不能修改它。
const的作用与#define相似，但它消除了#define的不安全性。

const与指针一起使用，可归纳为3种：指向常量的指针、常指针和指向常量的常指针。
（1）指向常量的指针是指一个指向常量的指针变量，例如：
const char * name ="chen";//声明指向常量的指针
含义：声明一个名为name的指针变量，它指向一个字符型常量，初始化name为指向字符串“chen”。
（2）常指针是指把指针所指的地址，而不是它指向的对象声明为常量，例如
char * const name="chen";//常指针
含义：声明一个名为name的指针能量，该指针是指向字符型数据的常指针，用“chen”的地址初始化该常指针。
（3）指向常量的常指针是指这个指针本身不能改变，它所指向的地址中数据也不能改变。要声明一个指向常量的常指针，二者都要声明为const，例如：
const char * const name="chen";//指向常量的常指针
含义：声明一个名为name的指针变量，它是一个指向字符型常量的常指针，用“chen”的地址初始化该指针。

（1）如果用const定义的是一个 整型常量，关键字int可以省略。
（2）常量一旦被建立，在程序的任何地方都不能再更改。
（3）const定义的常量可以有自己的数据类型。
（4）函数的形参也可以用const说明，用于保证形参在该函数内部不能被改动。

6. 函数原型

在C++中，如果函数调用的位置在函数定义之前，则要求在函数调用之前必须对所调用的函数作函数原型声明，以说明函数的名称、参数类型与个数，以及函数返回值得类型。其主要目的是让C++编译程序进行检查，已确定调用函数的参数以及返回值类型与事先定义的原型是否相符，以保证程序的正确性。

int add（int a,int b）；//就是函数add的原型

函数原型的语法格式一般为：函数返回类型 函数名（参数表）；

说明：
（1）函数原型的参数表中可不包含参数的名字，而只包含他们的类型。long Area (int,int);
（2）函数定义由函数说明和函数体两个部分构成。函数说明部分与函数原型基本一样，但函数说明部分中的参数必须给出参数的名字，而且不包含结尾的分号，例如：
long Area (int length ,int width)//函数的说明部分
{
……
return (length * width);
}
（3）主函数main不必进行原型说明。
（4）标准C++要求main函数必须声明为int型，即要求主函数带回一个整型函数值。C++通常是这样处理的：如果程序正常结束，则在main函数的最后加一条语句“return 0；”，向操作系统返回函数值0；如果函数执行不正常，则返回数值-1。
（5）如果一个函数没有返回值，则必须在函数原型中注明返回类型为void，函数的最后就不必有 “return;” 之类的返回语句了。
（6）

7. 内联函数

在函数说明前冠以关键字“inline”，该函数就被声明为内联函数，又称内置函数。
目的：消除函数调用时的系统开销，以提高运行速度。

#include<iostream>
using namespace std;
inline int box (int i,int j,int k);//函数原型，注意左端有inline
int main()
{
	int a,b,c,v;
	cin>>a>.b>>c;
	v=box(a,b,c);
	cout<<"a*b*c="<<v<,endl;
	return 0;
}
inline int box (int i,int j,int k)//定义box()为内联函数
{
	return i*j*k;
}
程序运行结果如下：
3 4 5(输入3、4、5分别给a、b、c)
a*b*c=60

说明：
（1）内联函数在第1次被调用前必须进行完整的定义，否则编译器无法知道插入什么代码。
（2）在内联函数体内一般不含有复杂的控制语句，如for语句和switch语句等。
（3）通常只有规模很小（一般1~5条语句）而使用频繁的函数才定义为内联函数，这样可大大提高运行速率。
（4）使用内联函数替代宏定义，就能消除宏定义的不安全性。

8. 带有默认函数的参数

在进行函数调用时，编译系统按从左到右顺序将实参与形参结合，若未指定足够的实参，则编译系统按顺序用函数原型中的形参默认值来补足所缺少的实参。

说明：
（1）在声明函数时，所有指定默认值的参数都必须出现在不指定默认值的参数的右边。
int fun (int i,int k,int j=5);
（2）在函数调用时，若某个参数缺省，则其后的参数皆省略采用默认值。不允许某个参数省略后，在给其后的参数指定参数值。
（3）如果函数的定义在函数调用之前，则应在函数定义中指定默认值，如果函数的定义在函数调用之后。则函数调用之前需要有函数声明，此时必须在函数声明中给出默认值，在函数定义时就不要给出默认值了。

9. 函数的重载

在C++中函数可以重载。只要函数参数的类型不同，或者参数的个数不同，或者两者兼而有之，两个或两个以上的函数可以使用相同的函数名。

说明：
（1）调用重载函数时，函数返回值类型不在参数匹配检查之列。因此，若两个函数的参数个数和类型都相同，而只有返回值类型不同，则不允许重载。
（2）函数的重载与带默认值的函数一起使用时，有可能引起二义性。
（3）函数调用时，如果给出的实参和形参类型不相符，C++编译器会自动地做类型转化工作。如果转化成功，则程序继续执行，在这种情况下，有可能产生不可识别的错误。

10. 作用域运算符“：：”

（1）通常情况下，如果有两个同名变量，一个是全局的，一个是局部的，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局能量。
（2） 如果希望在局部变量的作用域内使用同名的全局变量，可以在该变量前加上“：：”。

#include <iostream>
using namespace std;
int avar;
int main()
{
	int avar;
	avar=25;//给局部变量avar赋值
	::avar=10;//给全局变量avar赋值
	cout<<"local avar="<<avar<<endl;//输出局部变量avar的值
	cout<<"global avar="<<::avar<<endl;//输出全局变量avar的值
	return 0;
}
程序运行结果：
local avar=25
global avar=10

11. 无名联合

无名联合是C++中的一种特殊联合，它在关键字union后面没有给出联合名，它可使一组数据成员共享同一内存地址。如：
union
{ int i;
double d;
} x;
在无名联合中，无名联合变量x中的整型成员i和双精度型d具有相同的内存地址。在访问无名变量时，不能访问无名联合变量，而应该访问联合变量中的成员。例如：
x.i （访问无名联合变量x中的整型成员i）
x.d （访问无名联合变量x中的双精度型成员d）

12. 强制类型转换

int i=10;
double x=double(i);

int i=10;
double x=(double)i;

13. 运算符 new 和 delete

运算符new用于内存分配的最基本形式为：
指针变量名=new 类型
在程序运行过程中，运算符new从称为堆的一块自由存储区中为程序分配一块与类型字节数相适应的内存空间，并将该换内存的首地址存于指针变量中。例如：
p=new int;//new动态分配存放一个整数的内存空间，并将其首地址赋给指针变量p

运算符delete用于释放运算符new分配的存储空间。该运算符释放存储空间的基本形式为：
delete 指针变量名
其中，指针变量保存着new分配的内存的首地址。例如：
delete p;//将new动态分配内存的空间释放（其首地址已存放在指针变量p中）

#include<iostream>
using namespace std;
int main()
{
	int *ptr;//定义一个整型指针变量ptr
	ptr=new int;//动态分配一个整型存储空间，并将首地址赋给ptr
	* ptr=10;
	cout<< * ptr;
	delete ptr;//释放指针ptr指向的存储空间
	return 0;
}
程序运行结果如下：
10

说明：
（1）使用new可以为数组动态分配内存空间，需要在类型名后面缀上数组大小。
（2）new可以为简单变量分配内存的同时，进行初始化。其基本形式为：
指针变量名=new 类型（初值）；
初始值放在“类型”后面的圆括号内。但是，new不能对动态分配的数组存储区进行初始化。
（3）释放动态分配的数组存储区时，可使用如下的delete格式：
delete【】指针变量名；

14. 引用

（1）引用的概念
为一个变量、函数等对象规定一个别名，该别名称为引用。此后，对别名的操作即是对别名所代表的对象的操作。
类型 & 引用名=已定义的变量名；
int i=5;
int & j=i; //声明 j 是一个整型变量的引用，用整型变量 i 对它进行初始化
（2）引用作为函数参数

#include <iostream>
using namespace std;
void swap (int &m,int &n)//形参m和n是整数类型变量的引用
{
	int temp;
	temp=m;
	m=n;
	n=temp;
}
int main()
{
	int a=5,b=10;
	cout<<"a="<<a<<" b="<<b<<endl;
	swap(a,b);//实参a和b是整型变量，可以通过引用来修改实参a和b的值
	cout<<"a="<<a<<" b="<<b<<endl;
	return 0;
}
程序运行结果如下：
a=5 b=10
a=10 b=5

（3）使用引用返回函数值
使用引用可以返回函数的值，采用这种方法可以将该函数调用放在赋值运算符的左边。

#include<iostream>
using namespace std;
int a[]={1,3,5,7,9};
int &index(int);//声明函数返回一个整数类型的引用
int main()
{
	index(2)=25;//将函数调用放在赋值运算符的左边，等价于将a[2]赋值为25
	cout<<index(2);//等价于输出数组元素a[2]的值
	return 0;
}
int &index(int i)
{
	return a[i];//定义函数返回一个整数类型的引用，等价于返回数组元素a[i]
}
程序运行结果如下：
25