视频1-10（引用、指针、const、动态内存分配、内联函数）

一、引用

 

int i;
int &r=i;//r是i的别名

int &ref = 10;//错误，引用只能绑定在对象上

 

注意事项：必须初始化且为变量，不能是常量；从一而终。

1、简单的引用例子

 

void swap(int &a, int &b)  //引用就是别名，数值关联上
{
	int tmp;
	tmp = a; a = b; b = tmp;
}
int n1, n2;
swap(n1, n2);

2、引用作为函数返回值（？）

 

 

int n = 4;
int & setvalue()  //函数的返回值是整型的引用
{
	return n;//函数的返回值引用了n
}
int main()
{
	setvalue() = 40;// 函数调用返回值即n，进行赋值
	cout << n;
	return 0;
}

3、常引用

 

常引用让实参变量 拥有只读属性。

 

int n = 4;
const int &r = n;
r = 200;//编译出错

 

 

二、指针

对象是指一块能存储数据并具有某种类型的内存空间，有值a和地址&a。

 

 

指针也是对象，指针的地址是指向函数的起始地址。但引用不是对象，没有实际地址。

取地址符&，解引用符*

1、定义指针

int(*pf)(int,char)
函数返回类型（*指针变量名）（参数类型1、参数类型2）

 

void printmin(int a, int b)//原函数
{}
int main()
void (*pf)(int, int);//定义指针类型
int x = 4, y = 5;
pf = printmin;//函数赋值给指针
pf(x, y);//可以通过指针调用函数
return 0;

2、指针访问对象（通过指针改变所指对象值）

 

int ival = 42;
int *p = &ival;
cout << *p;//为*p赋值等于为所指对象赋值。

 

 

由符号*得到指针p所指的对象

 

3、void定义了一个空指针，可以存放任意对象的地址 void *p=&d

 

三、const

定义一种变量，它的值不能被改变，所以必须初始化

const int bufsize = 512;//所有bufsize都换成512.

 

1、引用和const

reference to const

const int ci = 89;
const int &r1 = ci;//正确，引用及其对象都是常量
r1=42//错误，r1是对常量的引用
int &r2=ci//错误，试图让一个非常量引用指向一个常量对象

 

 

与普通引用不同， 不可以通过引用修改他所绑定的对象

int i=42;//没有规定指向的对象必须是一个常量，只是想表达不能通过指针或引用修改对象。

const int &j=i;

 

2、指针和const

2.1  pointer to const   不可以通过常量指针修改其指向的内容。

int n, m;
const int *p = &n;//指向常量的指针
*p = 5;//编译出错
n = 4;
p = &m;//常量指针的指向可以发生变化const int *p = &n;//指向常量的指针
*p = 5;//编译出错
n = 4;
p = &m;//常量指针的指向可以发生变化

 

2.2 const pointer   不变的是指针本身的值

 

int i = 89;
int *const p = &i;//常量指针，指针的地址不变int *const p = &i;//常量指针，指针的地址不变

 

 

2.3 不能把常量指针赋值给非常量指针，反过来可以

 

 

const int *p1; int *p2;
p1 = p2;//可以
p2 = p1;//错误，常量指针指向的对象一般不变。
p2 = (int *)p1;//强制类型转换为非常量指针，可以赋值

3、

涉及知识点：

 

 

指针与const：

1：指向常量的指针：要想存放变量的地址，必须使用指向常量的指针：const int *p

2:常量指针：指针自身是一个对象，不可变。int *const p = &pi   （常量指针必须初始化！！！）

3：指向常量的常量指针。const  int *const p (不仅指针本身不可变，指针所指对象也不可变)

引用与const：

 

 

将引用定义为常量：const int &i

 

 

 

 

四、动态内存分配

1、new分配空间

P=new T  //P是指针，动态分配出大小为sizeof(T)的空间，且起始地址赋值给P.

 

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

P=new T[N]  //分配数组元素个数为N，内存大小为N*sizeof（T）

 

new运算返回值类型为T*

int *p=new int; //就是new 后面元素加*

 

1、new() ：分配这种类型的一个大小的内存空间,并以括号中的值来初始化这个变量;

2、 new[] ：分配这种类型的n个大小的内存空间,并用默认构造函数来初始化这些变量;  

2、用delete释放空间

 

int *p = new int;
*p = 5;
delete p;//单个变量


int *p = new int[20];
p[0] = 1;
delete[] p;//数组

五、内联函数（inline）、函数重载、函数缺省参数

 

1、编译器处理内联函数调用语句时，将整个函数代码插入调用句中。没有函数入栈出栈的操作。

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

2、函数重载：函数名字相同，参数不同。

record lookup(const account &acct);
record lookup(const account &);//省略了形参的名字

typedef phone telno
record lookup(const phone&);
record lookup(const Telno&)//telno与phone类型相同

 

3、函数缺省参数：提高程序的扩充性。

 

若需要添加新参数，缺省函数避免对原来函数调用语句的修改。

六、面向对象程序设计方法

1、结构化程序设计

复杂的大问题，，，层层分解/模块化，，，，子问题。

程序=数据结构+算法
面向对象的程序=类+类+类+.....