C++学习篇——基础知识

一 C++的结构特性

       ~~~~~~       一个面向对象的c++程序一般由类的声明和类的使用量大部分组成。

#include     // 编译预处理命令
using namespace std;   // 使用命名空间std
// 类的声明部分
class A                // 声明一个类，类名为A
{
	private：
		int x, y, z;    // 声明类A的数据成员
		...
	public：
		fun(){...}      // 声明类A的数据函数
		...
};
// 类的使用部分
int main()
{
	A a;                // 定义类A的一个对象a
	...
	a.fun();			// 调用对象a的成员函数fun
	return 0;
}

二. C++在非面向对象方面对C的扩充

1. 注释行

x = y + z;  /* this is a comment */
x = y + z;  // this is a comment

2. C++ 的输入和输出

// 标准输入流对象 cin
cin >> a >> b >> c;
// 标准输出流对象 cout
cout << a << b << c << endl;
// 设置域宽的操纵符setw(n)

3. const修饰符

      ~~~~~       使用const来定义常量

// const float PI = 3.14 常量PI是类型化的，可以用指针指向它，但不能修改它
// define T1 a+a;define T2 T1-T1;解析后T2 = a+a-a+a
/**
const 与 指针一起使用：
（1）指向常量的指针：一个指向常量的指针变量
    const char* pc = "abcd" //声明一个名为pc的指针变量，它指向一个字符型常量，初始化pc为指向字符串"abcd"
    pc[3] = "x"  // [X] 不允许改变指针所指的常量
    pc = "efgh"  // [V] 赋值给指针另一个字符串的地址
（2）常指针：把指针变量所指的地址，而不是它所指向的对象声明为常量（创建一个不能移动的指针，不能改变指针所指的地址，但是可以改变数据）
    char* const pc = "abcd" // 声明一个名为pc的指针变量，该指针是指向字符型数据的常指针，用字符串abcd来初始化
    pc[3] = 'x' // [X]，可以改变常指针pc所指地址中的数据
    pc = "efgh" // [V]，不能改变常指针所指的地址
（3）指向常量的常指针：指针所指向的地址和地址中的数据均不能改动
    const char* const pc = "abcd"
    pc[3] = 'x' // [X]
    pc = "efgh" // [X]
**/

4. void型指针

       ~~~~~~       void通常表示无值，但讲void作为指针的类型时，它却表示为不确定的类型。

5. 内联函数

/**
关键字：inline
原理：编译器使用函数体中的代码插入到调用该函数的语句处，同时用实参取代形参，程序运行时不再进行函数调用
原因：消除函数调用时的系统开销，提高运行速度；消除宏定义的不安全性
注意：
    a. 内联函数在第一次调用前必须进行完整的定义
    b. 内联函数内一般不含有复杂的控制语句，如for语句和switch语句
**/
#include 
using namespace std;
inline double circle(double r)    // 内联函数
{
	return 3.1416 * r　* r;
}
int main()
{
	for(int i = 1; i <= 3; i ++)
		cout << "r=" << i << " area= " <<　circle(i) << endl;
	return 0;
}

结果如下：

r=1 area= 3.1416
r=2 area= 12.5664
r=3 area= 28.2774

6. 带有默认参数值的函数

/**
C++允许实参个数和形参个数不同
说明：在函数原型中，所有取默认值的参数都必须出现在不取默认值的参数的右边，例如
        int fun(int i, int j = 5, int k);  [X]
        int fun(int i, int k, int j = 5);
**/

7. 函数的重载

/**
定义：在同一作用域内，只要函数参数的类型不同，或者参数的个数不同，或者二者兼而有之
说明：
    a. 调用重载函数时，函数的返回值类型不在参数匹配检查之列。
    b. 函数的重载与带默认值的函数一起使用时，有可能引起二义性
    c. 在函数调用时，如果给出的实参和形参类型不相符，c++编译器会自动地做类型转化工作，转化成功，继续执行，有可能产生不可识别的错误。
**/
#include
using namesapce std;
int add(int x, int y)	{	return x + y;	}
int add(int x, int y, int z)	{	return x + y + z;	}
int main()
{
	int a = 3, b = 4, c = 5;
	cout << a << "+" << b << "=" << add(a, b) << endl;
	cout << a << "+" << b << "+" << c  << "=" << add(a, b, c) << endl;
	return 0;
}

结果如下：

3+4=7
3+4+5=12

8. 作用域标识符 ::

        ~~~~~~~        通常情况下，如果有两个同名变量，一个是全局的，一个是局部的，那么局部变量在其作用域内具有较高的优先权，它将屏蔽全局变量。

#include 
using namespace std;
int aver = 10; 								//定义全局变量 aver
int main()
{
	int aver;								//定义局部变量 aver
	aver = 25;
	cout << "aver is " << aver << endl;		//输出局部变量 aver 的值
	return 0;
}

输出结果：

aver is 25

此时，在main()函数的输出语句中，使用的变量 aver 是在 main() 函数内定义的局部变量，因此输出的是局部变量 aver 的值。如果希望在局部变量的作用域内使用同名的全局变量，可以在该变量前加上 “::” ，此时 ::aver 代表全局变量 aver。

#include 
using namespace std;
int aver; 								//定义全局变量 aver
int main()
{
	int aver;								//定义局部变量 aver
	aver = 25;                              //给局部变量 aver 赋值
	::aver = 10;                            //给全局变量 aver 赋值
	cout << "local aver is " << aver << endl;		    //输出局部变量 aver 的值
    cout << "global aver is " << ::aver << endl;		//输出全局变量 aver 的值
	return 0;
}

输出结果：

local aver is 25
global aver is 10

9. new 和 delete

       ~~~~~~       C语言中使用函数 malloc 和 free 等进行动态内存管理，C++则提供运算符 new 和 delete 来做同样的工作。基本形式：
       ~~~~~~       指针变量名 = new 类型
       ~~~~~~       delete 指针变量名

#include
using namespace std;
int main()
{
	int *p;							//声明一个整形指针变量p;
	p = new int;					//动态分配一个存放int数据类型的内存空间，并将首地址赋给p;
	*p = 10;
	cout << *p;
	delete p;						//释放指针变量p指向的内存空间
	return 0; 					
}

说明：

1. new 可以自动计算索要分配的大小，而不必使用 sizeof() 来计算。
2. new 能够自动返回正确的指针类型，而不必对返回的指针类型进行强制类型转化。
3. 用 new 分配的空间，使用结束后只能用 delete 显示地释放，否则变为死空间。
4. new 分配空间时，如果没有足够的内存满足分配，将会返回空指针。
5. new 可为数组动态分配内存空间：指针变量名 = new 类型名[下标表达式]。

int *pi = new int[10];
int *pi = new int[1][2][3];

6. 释放动态分配的数组存储区时，可用 delete 运算符：delete [ ]指正变量名。

delete []pi;         //在指针变量前加一个[],表示对数组空间进行操作

7. new 可为简单变量分配内存空间的同时，进行初始化。

10. 引用

1. 引用的概念

       ~~~~~~       在c++中，变量的 “引用”就是对变量的别用，因此引用又称为别名。格式如下：类型 &引用名 = 已定义的变量名

int i = 5;
int &j = i;        //声明j是一个整形变量i的引用，用整形变量i对它进行初始化，及i变量的别名，具有相同的地址。

说明：

1. 引用并不是一种独立的数据格式，它必须与某种类型的变量相联系。在声明引用的时候对它立即进行初始化，不能声明完再赋值。

int i = 10;
int &j;            // [X], 没有指定j代表哪个变量
j = i;			   // [X], 不能声明完成后再赋值
double a;
int &b = a;		   // [X], 声明b是一个整形变量，而a不是

2. 为引用提供的初始值，可以是一个变量或者是另一个引用。

int i = 5;
int &j1 = i;		// 声明j1是整形变量i的引用
int &j2 = j1;		// 声明j2是整形引用j1的引用
// 这样定义后， 变量i有两个别名j1和j2

2. 引用作为函数参数

1. 将变量名作为函数的参数，这种传值是单向的，即“传值调用”，在执行期间形参值发生的变化并不会传回给实参（形参和实参不是占用同一个存储单元）。
2. 指针变量作为函数的参数，实参传给形参的是实参变量的地址，即“传址调用”，传值是双向的（同一个存储单元）。
3. 引用作为函数的参数，把变量的引用作为函数性形参，即传送变量的别名，传递是双向的。

#include
using namespace std;
void swap(int &m, int &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);
    cout << "a=" << a << " b=" << b << endl;
    return 0;
}

输出结果：

a=5 b=10
a=10 b=5

3. 使用引用返回函数值

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

4. 对引用的进一步说明

1. 不允许建立 void 类型的引用。

void &r = 10;   [X]

2. 不能建立引用的数组。

int a[4] = "abcd"
int &ra[4] = a;	[X]

3. 不能建立引用的引用，不能建立指向引用的指针。

int n = 3;
int &&r = n;	[X]
int &*p = n;	[X]

4. 可以将引用的地址赋给一个指针。

int a = 50;
int &b = a;
int *p = &b;

5. 可以用 const 对引用加以限制，不允许改变引用的值。

int a = 5;
const int &b = a;