一、从C语言到C++语言
1.C语言与C++的关系
C语言：众所周知，C语言是结构化和模块化的语言，是面向过程的。当程序的规模较小时，C语言运用起来得心应手。但是当问题比较复杂、程序的规模比较大的时候，C语言就会展现出它的局限性。
C++：正是因为有大规模的程序需要去处理，C++就应运而生了。C++是由C发展而来的，与C语言兼容。C++既可用于面向过程的结构化程序设计，也可用于面向对象的程序设计，是一种功能强大的混合型的程序设计语言。
总结：
1.C语言面向过程，C++既可以面向过程也可以面向对象。
2.C++是在C的基础上发展而来，C++是C语言的超集。
3.所有C语言的语法都可以用到C++当中。

2.C++在C基础上做了扩充
1.头文件
在C++中保留了部分C语言的头文件，去掉了后缀‘.h’， 在文件名前加上了‘c’，如下：
C风格 C++风格
stdio.h cstdio/iostream
math.h cmath
string.h cstring
stdlib.h cstdlib
… …
2.作用域
C语言中作用域只有两个：局部，全局。
C++中则是有：局部作用域，类作用域，名字空间作用域三种。
名字空间 名称空间 命名空间
namespace 命名空间

namespace myname
{
    
    
	int a;
	int Max();
	int Min();
}
namespace yourname
{
    
    
    int a;
    int Max();
}
int main()
{
    
    
	myname::Max();
	yourname::Max();
	return 0;
}

using 使用命名空间
using myname::a; //使用一个
using namespace myname; //使用所有的

3.输入输出
虽然我们尽可能的保留stdio.h，在C++中用作cstdio，但是C++使用iostream这样的头文件来作为输出输出头文件，iostream几乎涵盖了stdio.h所有的内容，并拓展了一些其他的应用。
在C语言中，我们是用printf、scanf这样的函数进行输入输出。
C++我们使用更加高级的cout cin endl，这些都是对象。在std中命名。

//一个简单的C++程序这样写
#include <iostream>		//输入输出头文件
using namespace std;		//使用std命名空间
int main()
{
    
    
	cout << "hello world" << endl; //输出"hello world"换行
	return 0;
}

#include <iostream>  
using namespace std; 
int main()
{
    
    
	cout << "hello" << endl;
	int  a = 10;
	float b = 20.5;
	char c = 'C';
	cout << a << " " << b << " " << c << endl;
	cin >> a;
	cin >> b;
	cin >> c;
	return 0;
}

4.基本数据类型
布尔类型：bool
1.在C++中新增了一中新的类型bool
2.bool类型只有两个常量值：true真 false假
3.实际运行时，把true当做1处理，把false当做0处理
4.bool类型是代码更加直观，区分逻辑真假与数值1和0
5.bool类型只占一个字节。
6.结构体
在C中，结构体名不能直接用作类型名，必须加上struct
在C++中，可以使用结构体名作为类型名，可以省略struct

//学生结构体 ：自定义的类型
struct Stu
{
    
    
	char name[20];
	int num;
	int age;
};

struct Stu ACan; // C里面 struct Stu
Stu Me; // C++使用Stu

在C中结构体内不能定义函数。
在C++中结构体内部可以定义函数。

//学生结构体 ：自定义的类型
struct Stu
{
    
    
	char name[20];
	int num;
	int age;

	void Fun();
	void GameInit();
};

6.强制类型转换

double a = 3.8;
double b = 6.6;
int c = 30, d;
d = c + (int)(a*b); //C风格
d = c + int(a*b);   //C++风格

7.条件运算符: ?:
在C语言中，条件运算表达式不能直接赋值。只能使用它的返回值。
在C++中，条件运算表达式可以赋值。条件运算表达式可以作为左值。

int a = 10;
int b = 15;
a > b ? a : b=20;    //15=20 错误的
(a > b ? a : b) = 20; //b=20 OK的

8.for循环
在C语言中for循环的循环变量必须提前定义，再使用。
在C++中，可以在for循环的表达式1定义循环变量，其作用域到循环结束。

int i;
for (i = 0; i < 10; i++)
{
    
    
	//C风格
}

for (int i = 0; i < 10; i++)
{
    
    
		//C++风格
}

9.作用域运算符 ::
1.如果::前面什么都没有，全局的。
2.类的作用域，命名空间

#include <iostream>
int a = 10;
int main()
{
    
    
    int a = 5;
    std::cout << "hello world" << std::endl;
    std::cout << ::a << std::endl;
    return 0;
}

10.动态内存分配
编程语言 开辟内存 释放内存 方式
C malloc free 函数
C++ new delete 运算符

int *p1 = new int;  //p1指向一个int的内存空间
int *p2 = new int(5);//p2指向一个int的内存空间，初始化为5
int *p3 = new int[5];//p3指向一个5个元素的int数组
delete p1;
delete p2;
delete []p3;

11.变量的引用： &
1.C++在C的基础上做出的重要扩充。
2.作用：为一个变量取别名，共享内存。
3.声明一个引用类型，并不会开辟新的空间。
4.声明引用类型时必须要初始化。

int a;  //声明一个变量a
int &b = a; //声明b是a的引用
//改变a即是改变b
a = 50;
cout << "b="<< b << endl;
//改变b即是改变a
b = 100;
cout << "a=" << a << endl;

12.内置函数–内联函数
编译过程：
1.预处理 .cpp —> .i
.cpp --> 展开头文件、库文件、宏定义
2.汇编 .i —> .S
把代码转化成汇编代码
3.编译阶段 .S —> .obj
把汇编代码转化成二进制
4.链接阶段 obj 2.obj 3.obj —>.exe
把.obj文件链接形成可执行文件

在调用函数时，需要一定时间和空间上的开销。如右图：
在C语言中，我们使用宏函数。
#define FUN(a,b) (a*b+a/b)

在C++中我们是用内联函数。
关键字 :inline
编译时，将所调用函数的代码直接嵌入到主调函数中。

注意：
1.内置函数只影响编译过程。
2.使用内置函数可以节省运行时间。但增加目标代码的长度。
3.只将规模很小的函数作为内置函数(5行以内)
4.内置函数不能包含复杂的控制语句，循环语句、switch语句。
5.inline并不是一个指令性的声明，只是程序员对编译系统的一种建议。
编译系统采纳不采纳，看情况。

13.带有默认参数的函数
1.在声明函数的时候，可以给定一些参数默认值。
2.调用的时候，缺省有默认值的参数，自动使用默认值。
3.调用时，实际参数个数 >= 形式参数个数 - 默认参数个数
4.默认参数必须放在右边。

#include <iostream>
using namespace std;
int Max(int a= 12, int b= 13, int c= 15)
{
    
    
	if (b > a)a = b;
	if (c > a)a = c;
	return a;
}
int main()
{
    
    
	int x = 10, y = 20, z = 18;
	cout << Max() << endl;
	cout << Max(x) << endl;
	cout << Max(x,y) << endl;
	cout << Max(x, y, z) << endl;
     return 0;
}

14.函数重载
1.同一个函数名，参数的个数、类型、顺序不一样。
2.返回值类型，不做参考。
1.同名同体，参数的类型不同

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

double Max(double a, double b, double c)
{
    
    
	if (c > a)a = c;
	if (b > a)a = b;
	return a;
}

2.同名不同体，参数的个数不同

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

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

总结：一名多用
1.函数名相同，参数的类型或者个数不同。
2.给函数名赋予新的含义,一个函数名多个作用。
3.细节不同的同一类功能。不要去实现完全不相干的功能。
4.参数的个数、类型、顺序至少有一种不同。返回值类型可以相同可以不同。
5.函数重载跟默认参数的函数不起冲突。

int Max(int a, int b, int c = 15)
{
    
    
	if (c > a)a = c;
	if (b > a)a = b;
	return a;
}

int Max(int a, int b)
{
    
    
	if (b > a)a = b;
	return a;
}
//以上2个函数：我们去调用： Max(10,15); 有歧义！！

6.函数重载的另一个重要作用：运算符重载
Complex operator+(Complex &c1, Complex &c2);

15.函数模板(function template)
函数模板：
1.建立通用的函数，函数的类型和形参的类型不用指定，而用一个虚拟的类型来代表。将数据类型参数化。
2.凡是函数体相同的多个函数都可以使用函数模板。
有以下重载函数：

int 		Max(int, int, int);
float 	Max(float, float, float);
double 	Max(double, double, double);

建立一种模板：
函数模板的声明：

template<typename _Ty1>   //这个_Ty1就是虚拟类型
template<class_Ty2>  	 //类模板

函数模板的定义：

_Ty1 Max(_Ty1 a, _Ty1 b, _Ty1 c)
{
    
    
	if (c > a)a = c;
	if (b > a)a = b;
	return a;
}

函数的调用：

int x=10, y=15, z=20;
int max = Max(x, y, z);
cout << max << endl;

float x1 = 10.2,  y1= 15.6,  z1 = 20.8;
float max1 = Max(x1, y1, z1);
cout << max1 << endl;

double x2 = 0.2,  y2 = 5.6,  z2 = 2.8;
double max2 = Max(x2, y2, z2);
cout << max2 << endl;

参数化：
将具体的数据，做成参数，去解决不同数据的问题。
将具体的数据类型，做成参数，去解决不同数据类型的问题。
参数化，是软件开发过程中必须具有的一种思维模式。它提出将各种相同的数据用参数来代替，实际使用的过程中，我们只需要将具体的数据或者类型带入到参数中即可.