【小白易懂】0. 面向对象语言 --- C++ (入门必备)

---

前言

本篇文章笔者将会对 CPP (基础入门) 部分进行详细讲解 , 以最易懂的方式介绍给学者 , 小白也能懂 , 相信通过本篇章学者将会对 CPP( C++) 入门更加容易 !

---

一、什么 C++ 语言 ?

● C++是一种计算机高级程序设计语言，‌由C语言扩展升级而产生。‌C++既可以进行C语言的过程化程序设计，‌又可以进行以抽象数据类型为特点的基于对象的程序设计，‌还可以进行以继承和多态为特点的面向对象的程序设计。‌

● C++是面向对象语言的一种 , 在 C 语言的基础上优化改进 , 让程序员运用起来更加方便.

---

二、C++ 的重要性

● 数据展示: 笔者以 TIOBE 编程语言排行榜的数据为例 . 以下是 TIOBE 7 月 最新编程语言排行榜统计数据 :

C++ 还是占有很不错的位置的 , 好多人都认为 C++ 难就不重要 , 这是非常错误的一个想法 .

● 用途: 提到 C++ 很多人就会立马想到游戏 , 其实 C++ 还是有很多方面的用途 .

C++的应用领域服务器端、游戏（引擎）、机器学习引擎、⾳视频处理、嵌⼊式软件、电信设备、⾦融
应⽤、基础库、操作系统、编译器、基础架构、基础⼯具、硬件交互等很多方面 .

---

三、C++ 入门基础

想要入门一门语言 , 那么就必须从语言的基础语法部分开始了解 .

◇ 第一个 C++ 程序

1. #include <iostream>
3. using namespace std;
5. int main()
6. {
7. cout << "Hello World !\n" << endl;
9. return 0;
11. }

复制代码

这里笔者将会为大家一 一 解释第一个 C++ 程序 .

● 对比第一个 C 语言程序 .

1. #include <stdio.h>
3. int main()
4. {
6. printf("Hello World !\n ");
8. return 0;
9. }

复制代码

命名空间

这是 C++ 对 C 的一个改进 , C 语言存在一个作用域无法使用同一名字的缺陷 . 那么想要使用同一名字来定义便不可行了. 所以 C++ 中提出了 namespace 的概念 .

给以下 2 个程序

●

1. #include <stdio.h>
3. //#include <stdlib.h>
5. int rand = 10; // 全局变量
7. int main()
8. {
10. printf("%d\n" , rand);
12. return 0;
13. }

复制代码

●

1. #include <stdio.h>
3. #include <stdlib.h>
5. int rand = 10;
7. int main()
8. {
10. printf("%d\n" , rand);
12. return 0;
13. }

复制代码

运行以上 2 个程序, 会发现 第 2 个程序 出现了报错 .

这里提示 ’ rand ’ 函数重定义 , 为什么呢?

● 首先要了解一下 C 语言中 rand 函数 (生成随机数) 是包含在 库 中的 . (笔者之前扫雷有过讲解 , 可前往自行学习) !

● 变量 rand 为全局变量 , 库 也是作用在全局之中 . 这就与 C 语言中规定相违背了 , 于是引出 " namespace " 命名空间这样的概念 .

※ namespace 定义 :

● 定义命名空间，需要使用到 namespace 关键字，后面跟命名空间的名字，然后接⼀对 " {} " 即可，{} 中即为: 命名空间的成员。命名空间中可以定义 变量/ 函数/ 类型等。

● namespace 本质 是 定义出⼀个域，这个域跟全局域各自独立，不同的域可以定义同名变量 .

● C++中域有函数局部域，全局域，命名空间域，类域；域影响的是编译时语法查找⼀个变量 / 函数 / 类型出处(声明或定义)的逻辑，所以有了域的隔离，名字冲突就解决了。

● 局部域和全局域除了会影响编译查找逻辑，还会影响变量的生命周期，命名空间域和类域不影响变量生命周期。

※ namespace 只能 定义在全局 , 它也可以嵌套定义 , 以下给出例子:

1. #include <iostream>
3. using namespace std;
5. // 嵌套定义 namespace
6. namespace AGE
7. {
8. namespace GJG
9. {
10. int age = 20;
11. }
13. namespace LiSi
14. {
15. int age = 24;
16. }
19. }
20. int main()
21. {
23. cout << "AGE::GJG::age: " << AGE::GJG::age << endl;
24. cout << "AGE::LiSi::age: " << AGE::LiSi::age << endl;
26. return 0;
28. }

复制代码

※ 项目工程中多文件中定义的同名namespace会认为是⼀个namespace，不会冲突。

■ 会默认合并到一起(逻辑上) , 向同一个 namespace 一样 . 以下给出例子:

定义一个栈

Stack.h

2. #include<stdio.h>
3. #include<stdlib.h>
4. #include<stdbool.h>
5. #include<assert.h>
7. //项目中多个文件协同时, 为了避免出现同一作用域同名的情况,使用命名空间解决
9. namespace GJG_Stack
10. {
11. typedef int STDataType;
12. typedef struct Stack
13. {
15. int top;
16. int capacity;
17. }ST;
19. void STInit(ST* ps, int n);
21. void STDestroy(ST* ps);
23. void STPush(ST* ps, STDataType x);
25. void STPop(ST* ps);
27. STDataType STTop(ST* ps);
29. int STSize(ST* ps);
31. bool STEmpty(ST* ps);
33. }

复制代码

Stack.cpp

2. #include "Stack.h"
4. namespace GJG_Stack
5. {
8. void STInit(ST* ps, int n)
9. {
11. }
13. void STDestroy(ST* ps)
14. {
16. }
18. void STPush(ST* ps, STDataType x)
19. {
21. }
23. void STPop(ST* ps)
24. {
26. }
28. STDataType STTop(ST* ps)
29. {
31. }
33. int STSize(ST* ps)
34. {
36. }
38. bool STEmpty(ST* ps)
39. {
41. }
43. }

复制代码

※ C++标准库都放在⼀个叫 std(standard) 的命名空间中。

所以在第一个 C++ 程序中 std:: 就表示限定了在 std 这个标准库中查找

※ 用 namespace 对 C 语言程序改进

● 补充 : " :: " , 本符号为作用域限定符号 . 限定函数查找的作用域.

1. #include <stdio.h>
3. #include <stdlib.h>
5. namespace GJG
6. {
7. int rand = 10;
8. }
10. int main()
11. {
13. printf("%d\n" , GJG ::rand);
15. return 0;
16. }

复制代码

可以看到很顺利的运行了 !

命名空间的使用

●
编译查找⼀个变量的声明/定义时，默认只会在局部或者全局查找，不会到命名空间里面去查找。所以下面程序会编译报错。

1. #include <stdio.h>
3. namespace GJG
4. {
5. int a = 5;
6. }
8. //int a = 10;
10. int main()
11. {
13. printf("%d\n", a); // 编译报错未声明标识符 a
15. return 0;
17. }

复制代码

所以我们要使用命名空间中定义的变量/函数，有三种方式:

▶指定命名空间展开

1. #include <stdio.h>
3. namespace GJG
4. {
5. int a = 5;
6. }
8. //int a = 10;
10. int main()
11. {
13. printf("%d\n", GJG::a); // 指定 在 GJG 域中查找
15. return 0;
17. }

复制代码

▶使用 using 全部展开

C语言版本

1. #include <stdio.h>
3. namespace GJG
4. {
5. int a = 5;
6. int b = 4;
7. int c = 3;
8. }
10. using namespace GJG;
12. int main()
13. {
15. printf(" a = %d\n", a);
16. printf(" b = %d\n", b);
17. printf(" c = %d\n", c);
19. return 0;
21. }

复制代码

C++ 版本

1. #include <iostream>
3. namespace GJG
4. {
5. int a = 5;
6. int b = 4;
7. int c = 3;
8. }
10. using namespace GJG;
11. using namespace std;
13. int main()
14. {
15. //未展开 std 域时
16. std::cout << "GJG :: a = " << GJG::a << std::endl;
17. std::cout << "GJG :: b = " << GJG::b << std::endl;
18. std::cout << "GJG :: c = " << GJG::c << std::endl <<endl;
19. //展开 std 域时
20. cout << "GJG :: a = " << GJG::a << endl;
21. cout << "GJG :: b = " << GJG::b << endl;
22. cout << "GJG :: c = " << GJG::c << endl;
24. return 0;
26. }

复制代码

▶使用 using 部分展开

● 意思是只展开常用的

C语言版本

1. #include <iostream>
3. namespace GJG
4. {
5. int a = 5;
6. int b = 4;
7. int c = 3;
8. }
10. using GJG::a; // 只展开常用的 a
12. int main()
13. {
14. printf("%d\n", a);
15. printf("%d\n", a);
16. printf("%d\n", a);
17. printf("%d\n", a);
18. printf("%d\n", a);
20. printf("%d\n", GJG ::c);
23. return 0;
24. }

复制代码

■ 补充: 这里发现没有包含头文件 也能执行 printf , 原因是 : C++ 兼容 大部分C 语言 .

C++ 版本

1. #include <iostream>
3. namespace GJG
4. {
5. int a = 5;
6. int b = 4;
7. int c = 3;
8. }
9. using namespace std;
11. using GJG::b;
13. int main()
14. {
15. cout << "GJG:: b = " << b << endl;
16. cout << "GJG:: b = " << b << endl;
17. cout << "GJG:: b = " << b << endl;
18. cout << "GJG:: b = " << b << endl;
19. cout << "GJG:: b = " << b << endl << endl;
21. cout << "GJG:: c = " << GJG::c << endl;
23. return 0;
25. }

复制代码

---

◇ C++ 的 输入 和 输出

● iostream 是 Input Output Stream的缩写，是标准的输入、输出流库，定义了标准的输入、输出对象。

● std::cin是istream类的对象，它主要面向窄字符（narrow characters (of type char)）的标准输入流。 其中 C 指 : characters (字符).

● std 是标准库 , cin , cout 是在标准库中.

● std::cout是 iostream 类的对象，它主要面向窄字符的标准输出流.

● cin 点击查看官网解释

● cout 点击查看官网解释 - 将代码中的变量转化为字符输出到终端控制台上

● std::endl (end line )是⼀个函数，流插入输出时，相当于插入⼀个换行字符加刷新缓冲区 .

● << 是流插入运算符，对应 cout , >>是流提取运算符 , 对应 cin .

※ cout /cin /endl等 都属于C++标准库，C++标准库都放在⼀个叫std(standard)的命名空间中，所以要通过命名空间的使用方式去用他们. 就要用到域限定符号 .

※ C++ 中能自动识别变量的类型

1. #include <iostream>
3. using namespace std;
5. int main()
6. {
7. int a = 0;
8. double b = 2.2;
9. char c = 'c';
11. cout << a << " " << b << " " << c << endl;
13. return 0;
15. }

复制代码

※ 输入 与 输出 代码

1. #include <iostream>
3. using namespace std;
5. int main()
6. {
7. int a = 0;
8. double b = 0.0;
9. char c = '0';
11. cin >> a >> b >> c; // 插入
13. cout << a << " " << b << " " << c << endl;
16. return 0;

复制代码

---

◇ 缺省参数

缺省参数也是 C++ 中比较重要的内容 , 这个可以为我们函数传参带来很大方便.

● 什么是缺省参数? : 缺省参数就是 : 声明或定义函数时为函数的参数指定⼀个缺省值。

※ 如果函数在传参时实参部分传了值 , 那么形参部分就使用实参部分传的值.

※ 如果函数在传参时实参部分未传值 , 那么形参部分就会使用缺省值.

◑ 代码展示:

1. #include <iostream>
3. using namespace std;
4. // 缺省参数
6. //全缺省
7. void Func1(int x = 1 , int y = 2 , int z = 3)
8. {
9. cout << "x = " << x << endl;
10. cout << "y = " << y << endl;
11. cout << "z = " << z << endl;
12. cout << endl;
13. cout << endl;
14. }
16. int main()
17. {
18. Func1(); //全部使用缺省值
20. Func1(4);
22. Func1(4, 5);
24. Func1(4,5,6); // 全部使用实参值
26. return 0;
28. }

复制代码

缺省值分为两种类型 :

● 全缺省

※ 形参部分全部都给了缺省值.

1. #include <iostream>
3. using namespace std;
4. // 缺省参数
6. //全缺省
7. void Func1(int x = 1 , int y = 2 , int z = 3)
8. {
9. cout << "x = " << x << endl;
10. cout << "y = " << y << endl;
11. cout << "z = " << z << endl;
12. cout << endl;
13. cout << endl;
14. }
16. int main()
17. {
18. Func1();
20. Func1(4);
22. Func1(4, 5);
24. Func1(4,5,6);
26. return 0;
28. }

复制代码

● 半缺省

※ 形参部分一部分给了缺省值.

1. #include <iostream>
3. using namespace std;
5. //半缺省
6. void func(int x , int y = 1 , int z = 2)
7. {
8. cout << "x = " << x << endl;
9. cout << "y = " << y << endl;
10. cout << "z = " << z << endl;
11. cout << endl;
12. cout << endl;
13. }
15. int main()
16. {
17. func(3);
19. func(3, 4);
21. func(3, 4, 5);
22. return 0;
24. }

复制代码

◑ 特别注意:

● 半缺省 的缺省参数只能从右往左依次连续缺省 , 不能跳跃缺省 .

● 带缺省参数的函数调用时 , 实参部分必须从左到右依次传参 , 不能跳跃传参.

※ C++ 规定 : 函数声明和定义分离时多个(多个文件时)，缺省参数不能在函数声明和定义中同时出现 , 必须在函数声明中给缺省值 .

以下给出例子: 实现栈

声明文件和定义文件中同时给缺省参数 , 错误示范!!!

Stack.h

1. #include <iostream>
2. #include <assert.h>
3. using namespace std;
5. typedef int STDataType;
7. typedef struct Stack
8. {
9. STDataType* a;
10. int top;
11. int capacity;
12. }ST;
14. void STInit(ST& ps, int n = 4); // 半缺省

复制代码

Stack.cpp

1. #include"Stack.h"
2. // 缺省参数不能声明和定义同时给
3. void STInit(ST& ps, int n = 4) // 此处为错误示范!!!!!! 应为 - ( int n )
4. {
5. ps.a = (STDataType*)malloc(n * sizeof(STDataType));
6. ps.top = 0;
7. ps.capacity = n;
8. }

复制代码

Test.cpp

2. #include"Stack.h"
4. int main()
5. {
6. ST s1;
7. STInit(s1);
8. // 确定知道要插⼊500个数据，初始化时⼀把开好，避免扩容
9. ST s2;
10. STInit(s2, 500);
11. return 0;
12. }

复制代码

出现报错 : “STInit”: 重定义默认参数 : 参数 1

※ 故: 只能在 .h 文件中给缺省值 .

---

◇ 函数重载

C++中允许同一作用域中出现同名函数 , 但有两个条件,这也是构成重载的条件:

● 函数参数的类型不同

● 函数参数的个数不同

◑ 代码展示:

● 函数参数的类型不同

2. #include <iostream>
4. using namespace std;
6. //函数重载
7. //函数参数类型不同
8. int Add(int x, int y)
9. {
10. return x + y;
11. }
13. double Add(double a , double b)
14. {
15. return a + b;
16. }
18. int main()
19. {
20. cout << "两个整数相加: " << Add(1, 3) << endl;
21. cout << endl;
22. cout << "两个浮点数相加: " << Add(2.2, 3.0) << endl;
24. return 0;
26. }

复制代码

● 函数参数的个数不同

1. #include <iostream>
3. using namespace std;
5. //函数重载
6. //函数参数个数不同
7. int func(int a , int b)
8. {
9. int c = a * b;
10. return c;
11. }
13. int func(int a)
14. {
15. int c = a * 1;
16. return c;
17. }
19. int main()
20. {
21. cout << "func(int a , int b) : " << func(2,3) << endl;
22. cout << endl;
23. cout << "func(int a) :" << func(6) << endl;
25. return 0;
26. }

复制代码

◑ 补充: 参数类型顺序不同也构成重载 – 实质上属于参数类型不同的一种.

1. //3、参数类型顺序不同
2. void f(int a, char b)
3. {
4. cout << "f(int a,char b)" << endl;
5. }
6. void f(char b, int a)
7. {
8. cout << "f(char b, int a)" << endl;
9. }

复制代码

◑ 特例: 以下两个函数构成重载 ,但在调用时会有歧义 ,编译器会报错

1. #include <iostream>
3. using namespace std;
5. void func()
6. {
7. cout << "func()" << endl;
8. }
10. void func(int a = 1) // 全省参数函数
11. {
12. cout << "func(int a)" << endl;
13. }
15. int main()
16. {
17. func();
19. return 0;
20. }

复制代码

分析: 全省参数函数在调用时可以不传实参 , 然而 两个 func 函数都会存在不传参的问题, 编译器就不知道调用谁了 , 就会出现报错.

---

◇ 引用

引用是 C++ 中非常重要部分 , 在实际用途中也起着很大的作用 .

◑ 概念: 可以这样理解 : 引用其实就是起别名 , 它并没有开辟空间 , 起了别名就完全可以替代原来的变量. 它和它引用的变量共用同⼀块内存空间。 但其底层是 : 指针.

● 表面上是传值 , 但底层是指针 , 不能片面的说引用就是传值.

◑ 符号: ’ & ’ 为引用符号 , 注意: C 语言中该符号为 : 取地址.

● 放在类型后为引用

● 放在变量前为取地址

◑ 代码展示:

1. #include <iostream>
3. using namespace std;
5. //引用
8. int main()
9. {
10. int a = 2;
12. int& b = a; // b 是 a 的别名
13. int& c = b; // c 是 b 的别名
15. c++;
17. cout << "a = " << a << endl;
18. cout << "b = " << b << endl;
19. cout << "c = " << c << endl;
20. cout << endl;
21. cout << endl;
23. cout << " &a = " << &a << endl;
24. cout << " &b = " << &b << endl;
25. cout << " &c = " << &c << endl;
27. //运行后会发现三者地址完全相同 .
28. return 0;
30. }

复制代码

◑ 引用的特性:

● 引用在定义时必须初始化

● 一个变量可以有多个引用 , 也可以对已经引用的变量进行引用

● 引用一旦引用了一个实体 , 就不能再引用其它实体了

1. #include <iostream>
3. using namespace std;
5. int main()
6. {
7. int a = 2;
8. int& b = a;
10. int c = 3;
11. int& b = c;
12. //会报错 b 多次初始化
14. }

复制代码

◑ 引用的使用:

● 引用在实践中主要是于引用传参和引用做返回值中减少拷贝提高效率和改变引用对象时同时改变被引用对象。

举个例子 , 交换两个变量的值 . 用引用就会很方便

1. #include <iostream>
3. using namespace std;
5. //交换两个变量的值
7. void Swap(int& pa , int& pb)
8. {
9. int tmp = pa;
10. pa = pb;
11. pb = tmp;
12. }
14. int main()
15. {
16. int a = 2;
17. int b = 3;
19. cout << "交换前: a = " << a << " " << "b = " << b << endl;
20. cout << endl;
22. Swap(a, b);
24. cout << "交换后: a = " << a << " " << "b = " << b << endl;
26. return 0;
28. }

复制代码

● 引用和指针在实践中相辅相成，功能有重叠性，但是各有特点，互相不可替代。C++的引用跟其他语言的引用(如Java)是有很大的区别的，除了用法，最大的点，C++引用定义后不能改变指向,Java的引用可以改变指向。

◑ const 引用:

● 可以引用一个 const 对象 , 但必须用 const 引用.

● 可以引用一个普通对象.(普通,产生临时变量的都可以)

▶引用一个const 对象

1. #include <iostream>
3. using namespace std;
5. //引用一个 const 对象
7. int main()
8. {
9. const int a = 10; // 修饰整体 -- 只可读 , 不可写入(不可改变a的值)
11. //int& b = a; // 放大了b 的权限, 是错误的
12. const int& b = a; //与a拥有一样的权限 , 只可读 , 不可写
14. return 0;
16. }

复制代码

▶引用一个普通对象

1. #include <iostream>
3. using namespace std;
5. //引用一个 普通 对象
7. int main()
8. {
9. int a = 20;
11. int& c = a; // ok
13. //引用对 b 权限的缩小
14. const int& b = a; // ok
16. return 0;
18. }

复制代码

▶特别注意: 三个会产生临时变量的情况:

◑: 临时变量是具有常性的 , 不能被修改!

◑: 传值返回

◑: 表达式运算

◑: 类型转换

▶传值返回

1. #include <iostream>
3. using namespace std;
5. //传值返回 - 产生临时变量具有常性
7. int fun(int a)
8. {
9. return a;
10. }
12. int main()
13. {
14. //int& ret = fun(1); // err
15. const int& ret = fun(1); // ok
16. // fun函数返回时先把值给了临时变量, 然后赋值给ret
18. return 0;
20. }

复制代码

▶表达式运算

1. #include <iostream>
3. using namespace std;
5. //表达式运算 - 产生临时变量具有常性
7. int main()
8. {
9. int a = 1;
10. int b = 2;
12. //int& c = a + b; // err
13. const int& c = a + b;
15. return 0;
17. }

复制代码

▶类型转换

2. int main()
3. {
4. int a = 1;
5. double b = a;
6. // int& rb = b; //“初始化”: 无法从“double”转换为“int &”
8. const int& rb = b;
10. return 0;
12. }

复制代码

总结

以上是笔者对于基础部分的大致讲解 , 内容同时也是笔者对于学习的总结 , 有不足的地方望指出! 喜欢笔者,持续关注哦!