【C++入门】从C到C++

从C到C++

一、“引用”的概念和应用

1.引用的概念

• 注意事项

  • 1.某个变量的引用，等价于这个变量，相当于该变量的一个别名
  • 2.定义引用时一定要将其初始化成引用某个变量。

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

  下面的写法定义了一个引用，并将其初始化为引用某个变量：

  int n = 4; 
  int & r = n; // r引用了 n, r的类型是 int &

2. 引用应用的简单示例

• 交换两个变量的值

  • C语言中， 编写交换两个整型变量值的函数

  void swap( int * a, int * b) 
  { 
  	int tmp; 
  	tmp = * a; * a = * b; * b = tmp; 
  } 
  int n1, n2; 
  swap(& n1,& n2) ; // n1,n2的值被交换

- 使用引用， 编写交换两个整型变量值的函数

  void swap( int & a, int & b) 
  { 
  	int tmp; 
  	tmp = a; a = b; b = tmp; 
  } 
  int n1, n2; 
  swap(n1,n2) ; // n1,n2的值被交换

• 引用作为函数的返回值

  int n = 4; 
  int & SetValue() { 
  	return n; 
  } 
  int main() 
  { 
  	SetValue() = 40; 
  	cout << n; 
  	return 0; 
  } //输出： 40

3.常引用

• 定义

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

• 示例

  int n; 
  const int & r = n; 

r 的类型是 const int &

• 常引用&引用

  • 不能通过常引用去修改其引用的内容

  int n = 100; 
  const int & r = n; 
  r = 200; //编译错 
  n = 300; // 没问题

- 常引用和非常引用的转换

  const T & 和T & 是不同的类型
  
  1.T & 类型的引用或T类型的变量可以用来初始化const T & 类型的引用。
  2.const T 类型的常变量和const T & 类型的引用则不能用来初始化T &类型的引用，除非进行强制类型转换。

补充：“const”关键字的用法

1) 定义常量

• 示例：const int MAX_VAL = 23；
• 优点（相对define）：便于类型检查

2) 定义常量指针

• 作用

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

• 示例：

int n,m;
const int * p = & n;

• 注意：

  • 示例

  const int * p1; int * p2; 
  p1 = p2; //ok 
  p2 = p1; //error 
  p2 = (int * ) p1; //ok,强制类型转换

- 不可通过常量指针修改其指向的内容
- 不能把常量指针赋值给非常量指针，反过来可以

3) 定义常引用

二、 动态内存分配

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

• 分配一个变量：P = new T;

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

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

• 分配一个数组：P = new T[N];

  T :任意类型名
  P :类型为T * 的指针
  N :要分配的数组元素的个数，可以是整型表达式
  动态分配出一片大小为 sizeof(T)*N字节的内存空间，并且将该内存空间的起始地址赋值给P。

  动态分配数组示例：

  int * pn; 
  int i = 5; 
  pn = new int[i * 20]; 
  pn[0] = 20; 
  pn[100] = 30; //编译没问题。运行时导致数组越界

2.用delete运算符释放动态分配的内存

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

• 释放一个变量的空间：delete 指针；

  //该指针必须指向new出来的空间 
  int * p = new int; 
  * p = 5; 
  delete p; 
  delete p; 
  //导致异常，一片空间不能被delete多次

• 释放一个数组空间：delete [ ] 指针；

  //该指针必须指向new出来的数组 
  int * p = new int[20]; 
  p[0] = 1; 
  delete [ ] p;

三、内联函数

1.以空间换时间

 函数调用是有时间开销的。如果函数本身只有几条语句，执行非常快，而且函数被反复执行很多次，相比之下调用函数所产生的这个开销就会显得比较大。
 为了减少函数调用的开销，引入了内联函数机制。编译器处理对内联函数的调用语句时，是将整个函数的代码插入到调用语句处，而不会产生调用函数的语句。

2.定义

• inline 函数名（）{函数体}；
• 示例

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

3.注意：

• 调用内联函数之前要有函数的定义，不能只有声明。

四、函数重载

1.意义

• 函数重载使得函数命名变得简单。

2.定义

• 一个或多个函数，名字相同，然而参数个数或参数类型不相同，这叫做函数的重载。
• 编译器根据调用语句的中的实参的个数和类型判断应该调用哪个函数。

3.示例

以下三个函数是重载关系：

int Max(double f1,double f2) { } 
int Max(int n1,int n2) { } 
int Max(int n1,int n2,int n3) { }

五、函数缺省参数

1.意义

• 函数参数可缺省的目的在于提高程序的可扩充性。

  即如果某个写好的函数要添加新的参数，而原先那些调用该函数的语句，未必需要使用新增的参数，那么为了避免对原先那些函数调用语句的修改，就可以使用缺省参数。

2.定义

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

3.示例

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) ; //不行,只能最右边的连续若干个参数缺省

六、类和对象基本概念

I 结构化程序设计

1.特点

• 程序由全局变量以及众多相互调用的函数组成
• 算法以函数的形式实现，用于对数据结构进行操作

2.不足

• 结构化程序设计中，函数和其所操作的数据结构，没有直观的联系。

  随着程序规模的增加，程序逐渐难以理解，很难一 下子看出来：
  某个数据结构到底有哪些函数可以对它进行操作？
  某个函数到底是用来操作哪些数据结构的？
  任何两个函数之间存在怎样的调用关系？

• 结构化程序设计没有“封装”和“隐藏”的概念

  1.要访问某个数据结构中的某个变量，就可以直接访问，那么当该变量的定义有改动的时候，就要把所有访问该变量的语句找出来修改，十分不利于程序的维护、扩充。
  2.难以查错，当某个数据结构的值不正确时，难以找出到底是那个函数导致的。

• 难以进行代码重用

  重用：在编写某个程序时，发现其需要的某项功能，在现有的某个程序里已经有了相同或类似的实现，那么自然希望能够将那部分代码抽取出来，在新程序中使用。
  在结构化程序设计中，随着程序规模的增大，由于程序大量函数、变量之间的关系错综复杂，要抽取这部分代码，会变得十分困难。

II 面向对象程序设计

面向对象的程序 = 类 + 类 + …+ 类

1.面向对象的程序设计方法

1.将某类客观事物共同特点（属性）归纳出来，形成一个数据结构（可以用多个变量描述事物的属性）；
2.将这类事物所能进行的行为也归纳出来，形成一个个函数，这些函数可以用来操作数据结构(这一步叫“抽象”）。
然后，通过某种语法形式，将数据结构和操作该数据结构的函数“捆绑”在一起，形成一个“类”，从而使得数据结构和操作该数据结构的算法呈现出显而易见的紧密关系，这就是“封装”。

2.基本特点

• 抽象
  抽象就是解释类与对象之间关系的词。类与对象之间的关系就是抽象的关系。一句话来说明：类是对象的抽象，而对象则是类得特例，即类的具体表现形式。
• 封装
  封装两个方面的含义：一是将有关数据和操作代码封装在对象当中，形成一个基本单位，各个对象之间相对独立互不干扰。二是将对象中某些属性和操作私有化，已达到数据和操作信息隐蔽，有利于数据安全，防止无关人员修改。把一部分或全部属性和部分功能（函数）对外界屏蔽，就是从外界（类的大括号之外）看不到，不可知，这就是封装的意义。
• 继承
  面向对象的继承是为了软件重用，简单理解就是代码复用，把重复使用的代码精简掉的一种手段。如何精简，当一个类中已经有了相应的属性和操作的代码，而另一个类当中也需要写重复的代码，那么就用继承方法，把前面的类当成父类，后面的类当成子类，子类继承父类，理所当然。就用一个关键字extends就完成了代码的复用。
• 多态
  没有继承就没有多态，继承是多态的前提。虽然继承自同一父类，但是相应的操作却各不相同，这叫多态。由继承而产生的不同的派生类，其对象对同一消息会做出不同的响应。

【知识索引】【C++入门】