C++入门笔记（1）

前言

郭炜老师讲的还是很清楚的

第一章：从 C 到C++

引用

类型名 & 引用名 = 某变量名;

1 2	int n = 4; int & r = n;

r引用了n，r的类型是int &

之后对r的修改就是对n的修改，对n的修改就是对r的修改

定义引用时一定要将其初始化成引用某个变量，之后不会再引用其他变量

在C语言中，我们可以通过指针实现两个数交换

void swap( int * a, int * b)
{
int tmp;
tmp = * a; * a = * b; * b = tmp;
}
int n1, n2;
swap(& n1,& n2) ;

有了C++的引用以后，可以这样写

void swap( int & a, int & b)
{
int tmp;
tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1,n2) ;

引用作为函数的返回值

int n = 4;
int & SetValue() 
{ 
    return n; 
}
int main() 
{
	SetValue() = 40;//类似于指针指向n
	cout << n;
	return 0;
} //输出：40

常引用

定义引用时，前面加const关键字，即为“常引用”

1 2	int n; const int & r = n;

r 的类型是 const int &

注意：不能通过常引用去修改其引用的内容

“const”关键字的用法

定义常量指针，不可通过常量指针修改其指向的内容，但可以修改指向

意义：函数参数为常量指针时，可避免函数内部不小心改变参数指针所指地方的内容

动态内存分配

用new 运算符实现动态内存分配

第一种用法，分配一个变量:

1	P = new Type;

T是任意类型名，P是类型为T 的指针。动态分配出一片大小为 sizeof(T)字节的内存空间，并且将该内存空间的*起始地址赋值给P，如：

1
2
3

int * pn;
pn = new int; 
* pn = 5;

第二种用法,分配一个数组：

P = new T[N];

int * pn;
int i = 5;
pn = new int[i * 20];
pn[0] = 20;

用“new”动态分配的内存空间，一定要用 “delete”（delete指针）运算符进行释放

int * p = new int;
* p = 5;
delete p;//只能释放一次
//对于数组：
int * p = new int[20];
p[0] = 1;
delete [ ] p;

内联函数

可以减少一些很简单的函数过多调用造成的开销

如：

inline int Max(int a,int b)
{
if( a > b) return a;
return b;
}

函数重载

一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载。

int Max(double f1,double f2) { }
int Max(int n1,int n2) { }
int Max(int n1,int n2,int n3) { }
Max(3.4,2.5); //调用 (1)
Max(2,4); //调用 (2)
Max(1,2,3); //调用 (3)
Max(3,2.4); //error,二义性

编译器会根据调用语句的中的实参的个数和类型判断应该调用哪个函数

函数的缺省参数

C++中，定义函数的时候可以让最右边的连续若干个参数有缺省值，那么调用函数的时候，若相应位置不写参数，参数就是缺省值。

void func( int x1, int x2 = 2, int x3 = 3) 
{ }
func(10 ) ; //等效于 func(10,2,3)
func(10,8) ; //等效于 func(10,8,3)
func(10, , 8) ; //不行,只能最右边的连续若干个参数缺省

目的在于提高程序的可扩充性