C++简介，Const常量，人机交互，引用，带缺省值的函数与函数的重载，内存的动态申请与回收，知识全面总结

假期停学不停课，我们一起来学习C++
面向对象程序设计语言：
博主问：

1. 面向过程和面面向对象的区别？
2. 程序设计范型的定义？
3. C和C++的区别与联系？

1.1C++简介：

C++ 是一种静态类型的、编译式的、通用的、大小写敏感的、不规则的编程语言，支持过程化编程、面向对象编程和泛型编程。
C++ 被认为是一种中级语言，它综合了高级语言和低级语言的特点。
C++ 进一步扩充和完善了 C 语言，是一种面向对象的程序设计语言。C++ 可运行于多种平台上，如 Windows、MAC 操作系统以及 UNIX 的各种版本。
C++ 是 C 的一个超集，事实上，任何合法的 C 程序都是合法的 C++ 程序。
注意：使用静态类型的编程语言是在编译时执行类型检查，而不是在运行时执行类型检查。

1、了解C++语言的发展历史

C++由美国贝尔实验室Bjarne Stroustrup （本贾尼·斯特劳斯特卢普）博士及其同事在上个世纪80年代设计并实现。
C++是从C语言发展演变而来的，首先是一个更好的C，引入了类的机制，最初的C++被称为“带类的C”，1983年正式取名为C++。
从1989年开始C++语言的标准化工作。
于1994年制定了ANSI（American National Standards Institute ）C++标准草案。
于1998年11月被国际标准化组织（ISO）批准为国际标准，成为目前的C++。
++ 是C++语言的操作符，外国科学家认为这种叫法很有趣。

2、了解C++与C语言的关系

C++ = C + 符号和语法扩充 + 面向对象
C++继承并发展了C，包含了C的所有语法； 保持了C的简洁性和高效性；弥补了C的不足之处，增加了对面向对象的程序设计的支持。

3、了解面向过程程序设计的局限性以及面向对象程序设计的主要优点

面向过程程序设计的局限性：
a）传统程序设计开发软件的生产效率低下
b）传统程序设计难以应付日益庞大的信息量和多样的信息类型
c）传统程序设计难以适应各种新环境
面向对象程序设计的主要优点：
(1)可提高程序的重用性
(2)可控制程序的复杂性
(3)可改善程序的可维护性
(4)能够更好地支持大型程序设计
(5)增强了计算机处理信息的范围
(6)能很好地适应新的硬件环境

4、理解面向对象程序设计语言的基本概念和基本特征

基本概念：
（一）对象：对象是类的实例化
对象是既包括属性（状态）数据，又包括作用于属性数据的一组操作的封装体。
对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
属性：
对象的属性数据或状态数据通常称为属性。
方法/服务：
对象的能力（功能），即能实现的操作称为方法或服务。
基本上说，一个方法表示一种行为。一个类可以包含多个方法。
可以在方法中写入逻辑、操作数据以及执行所有的动作。
注：在C++语言中，属性称作数据成员，服务/方法称为成员函数。
（二）类：类是对象的抽象
类就是具有相同的属性和相同的操作的一组对象的抽象。
类可以定义为描述对象行为/状态的模板/蓝图。
（三）消息
消息（Message）：是描述事件发生的信息，是一个对象向另一个对象发出的请求。
消息传递：面向对象程序设计技术所提供的一种允许一个对象与另一个对象交互的机制。
发送者或请求者：发送消息的对象
接受者或目标对象：接收消息的对象
基本特征：面向对象程序设计的4个基本特征：
抽象性
封装性
继承性
多态性
抽象：是将有关事物的共性归纳、集中的过程。
封装：指将数据和实现操作的代码集中放在对象内部，并尽可能隐蔽对象的内部细节。
继承：保持已有类的特性而构造新类的过程称为继承。
多态：是指不同的对象在收到相同的消息时产生多种不同的行为。

5、了解C++语言的广泛应用

1.2const常量

1、理解const与define的区别，掌握const的一般用法：常量，常数组的定义与使用。

宏定义 #define 和常量 const 的区别

类型和安全检查不同

宏定义是字符替换，没有数据类型的区别，同时这种替换没有类型安全检查，可能产生边际效应等错误；
const常量是常量的声明，有类型区别，需要在编译阶段进行类型检查

编译器处理不同

宏定义是一个"编译时"概念，在预处理阶段展开，不能对宏定义进行调试，生命周期结束与编译时期；
const常量是一个"运行时"概念，在程序运行使用，类似于一个只读行数据

存储方式不同

宏定义是直接替换，不会分配内存，存储与程序的代码段中；
const常量需要进行内存分配，存储与程序的数据段中

定义域不同

void f1 (){
#define N 12
const int n 12;}void f2 (){
cout<<N <<endl; //正确，N已经定义过，不受定义域限制
cout<<n <<endl; //错误，n定义域只在f1函数中}

定义后能否取消

宏定义可以通过#undef来使之前的宏定义失效
const常量定义后将在定义域内永久有效
void f1(){
#define N 12
const int n = 12;

#undef N //取消宏定义后，即使在f1函数中，N也无效了
#define N 21//取消后可以重新定义}

是否可以做函数参数

宏定义不能作为参数传递给函数
const常量可以在函数的参数列表中出现

使用 const 前缀声明指定类型的常量，如下所示：
const type variable = value;

2、掌握const与指针的组合使用：指向常量的指针、常指针、指向常量的常指针。（难点）

（1）指向常量的指针 —— 指针指向的是常量，内容不许变，但指针自身可以变

         const char * name = “liu”;  //定义了一个指针变量name，指向一个字符串常量
                                                       //const是修饰char的
         name[2] = ‘n’;      //非法,name指向的是一个常量，其内容不许变。
         name = "zhang";  //合法，name指向了另一个常量字符数组

（2）常指针 —— 指针指向位置不变，即指针本身不变，但指向内容可变

         char * const name = “liu”;  //const修饰name，定义了一个不动的指针
         name[2] = ‘n’;   //合法，里面的内容可变
         name = "zhang";   //非法，name不许指向另一个字符数组

（3）指向常量的常指针 —— 指针自身和其指向的内容都不许变

         const char * const name=“liu”;  //一个const修饰name
                                                              //还有一个const修饰char
         name[2]=‘n’;       //非法，指针指向的内容不许变。
         name="zhang";  //非法，指针也不能指向另一个字符数组

3、掌握const在函数中的使用场景。

1.常量的概述 const 类型 变量名 = 初始化表达式（等价 type const variable=value）
2.常变量的定义与使用 const type variable
3.常引用的定义与使用 const type & variable=initialize（初始化）
4.常对象 const 类型名 变量名 = 初始化表达式（Initializing expression）

4、了解常引用、常对象的一般用法。（同上）

1.3人机交互

在常用的头文件中包含有许多用于输入输出的类，下表列出了流类库中常用的流类，并指出了这些流类在哪个头文件中。

1、理解C++为何要建立自己的输入输出系统

1.C语言的输入输出系统不支持用户自定义的类类型
2.C语言对数据类型的检查不严格

2、了解输入输出可以进行哪些格式控制，如何进行常用格式控制

 cin是istream类的对象，用于处理标准输入设备(键盘)的输入;
 cout是ostream类的对象，用于处理标准输出设备(屏幕)的输出;
 cerr是ostream类的对象，用于处理在标准设备上输出出错信息(不带缓冲，即立即显示);
 clog是ostream类的对象，用于处理在标准输出设备上输出错误信息(带缓冲)，当缓冲区满时输出。

输入流

实例一：

实例二：

示例三：

输出流

示例一：

示例二：

3、掌握简单的输入和输出

1.4引用

1、掌握引用的概念，定义以及使用

引用可为变量起别名，主要用作函数的参数和返回类型，对引用的操作与对变量直接操作完全一样。 声明一个引用的格式为：

  类型 &引用名=已定义的变量名或引用；

使用及其说明：
1）定义引用的同时，必须对其进行初始化，除了用作函数参数或返回类型外。

2）引用不同于普通变量，下面声明非法：

	    不能建立引用的数组            int & a[9];
        不能建立指向引用的指针        int & *p;
        不能建立引用的引用            int & &px;
        不能建立void引用             void & a=x;
        
        不能用类型或NULL来初始化     
        int & a=int;   
        int & a =NULL;

3）引用符同取址符是有区别的：

type&——类型后的是引用符
	&i——变量前的为取址符

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

2、重点掌握引用作为函数参数

传指针调用和引用调用。当形参和实参结合时，传送的是变量的地址。
示例一：指针

#inlcude<iostream.h>    
void swap ( int *a, int *b )
{
  	int temp; 
	 temp=*a; 
 	*a=*b; 
	 *b=temp;   
}
void main ( )  
{
	int x=10, y=20;
	swap( &x, &y );  
	cout<<“x:”<<x<<“y:”<<y<<endl;
}

示例二：引用

 #inlcude<iostream.h>
 void swap ( int &a, int &b)
{
	int temp; 
	 temp=a; 
	 a=b; 
	b=temp;   
}
void main ( )  
{
	int x=10, y=20;
	swap( &x, &y );  
	cout<<“x:”<<x<<“y:”<<y<<endl;
}

3、理解引用和指针的异同点:C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：
不存在空引用。引用必须连接到一块合法的内存。
一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
引用必须在创建时被初始化。指针可以在任何时间被初始化。

1.5 带缺省值的函数与函数的重载

1、理解C++中函数的一般用法：函数原型声明，内联函数。

在C++中，如果函数调用的位置在函数定义之前，则要求在函数调用之前必须对所调用的函数作函数原型声明，目的是使编译器能更好的检查。
使用说明：
1、函数原型的参数表中可以没有参数的名字，而只有类型，如int Add(int,int)。
2、缺省的函数返回值为int类型。
内联函数也称内置函数，内联函数定义的形式就是在函数的函数类型前加上inline关键字即可，当编译器发现某段代码在调用一个内联函数时，它不是去调用该函数，而是将该函数的代码，整段插入到当前位置,同时将实参代替形参。这样做的好处是省去了调用的过程，加快程序运行速度。

2、掌握带缺省值的函数定义与调用方法：含一个缺省值的函数，含多个缺省值的函数。（难点）

C++函数声明原型时（若没有原型声明，则在函数定义时），可为若干参数指定默认值，以后调用如果省略一个或多个实参，C++自动将默认值作为其实参。
使用说明：
1、函数的形参与实参从左到右一一结合，实参 不足用默认参数补齐。
2、函数原型中带默认值的参数都必须出现在不指定默认值参数的右边。
3、调用时某一参数省略，其后参数均省略。

3、掌握函数重载的用法。（重点）

把同一作用域内名字相同，但参数不同（个数不同、类型不同、顺序不同）的函数称为重载函数。
（1）参数个数
（2）参数类型
（3）参数顺序
这三个方面上，至少有一个不同之处。
注意：参数相同只函数返回值类型不同，不算重载！

1.6 内存的动态申请与回收

1、理解C++中全局变量、局部变量的作用范围，掌握作用域运算符 :: 的用法。

C++程序中，有两个同名变量：一个全局的，另一个是局部，那么局部变量在其作用域内有较高优先权；如果要在这里使用全局变量，可以使用作用域运算符“::”

2、掌握C++中强制类型转换，union联合类型的用法。

C中把一个int数转换为float数：
int i=10;
float x=(float)i;
C++中不仅支持这样的格式，还提供了一种新的强制类型转换方法：
int i=10;
float x=float(i);
后者相当于函数调用，是C++推荐使用的方式。

3、理解C++中内存动态申请与回收机制，掌握new和delete的用法。（重点）

new和delete是内存管理运算符
C中使用malloc()和free()函数动态操作内存；C++使用new和delete运算符能更好、更简单的进行内存的分配和释放。
new使用形式： 指针变量=new type;
其中，type是一个数据类型名，new分配sizeof(type)字节的内存，首地址给指针变量；
delete使用形式： delete 指针变量;
使用说明：
1）new和delete的功能与malloc和free相似。
2）new能自动计算type的大小，更安全。
3）new能自动返回正确的指针类型，不用强制类型转换。
4）使用new为数组动态分配空间，如
int* pi=new int[10];
5）new可在分配空间的同时进行初始化。
如： int* p=new int(99);
6）动态释放数组使用如下的形式：
delete [ ]p；
7）new分配内存得不到满足时返回空指针NULL。

整理不易，转载请注明出处！
更多内容，往后会继续添加！
感谢