TouchGFX是一个基于STM32硬件，由C++写成的软件框架，所以有必要对C++基础有一定的了解

一. C++新特性

C语言里，变量初始化必须在程序的前面，而C++则可以随用随定义。C++也可以直接初始化，比如 int x(100)，这样就直接赋值 x=100C++的输入输出方式：以cin和cout代替了C语言里的scanf和printf

cout语法形式：

1. cout << x << endl;
   
2. // x 可以是任意数据类型（或表达式）
   # x1 E1 G  x! l7 x
3. // endl 是换行符，与C里的"\n"效果一样
   
4. cout << x << y << endl;  //多个变量的输出

复制代码

cin 语法形式：

1. cin >> x;  //x可以是任意数据类型
   ! ^( Z! i, w9 l2 g5 M1 s" Y
2. cin >> x >> y; //多个变量的输入

复制代码

C++的命名空间 namespace：using namespace std;

1. #include <iostream>
   2 a% c/ A) T: a
2. using namespace std;
   
3. int main(){
   , E  u7 |! `8 _# X% P" ^! C
4. cout << "Hello, World!" << endl;
   
5. return 0;
   - E9 S/ M: o. Q
6. }

复制代码

上面程序中，头文件要写成iostream，因为是标准输入输出流；带".h"的是非标准输入输出流。using是编译指令，声明当前命名空间的关键词，可理解成使用命名空间std，因为cin和cout都是属于std命名空间的，所以使用时须加上using namespace std，也可以写成std::cin和std::cout，其中 :: 表示作用域
$ N: T$ A* ~& N/ Y5 ~7 V6 T

为什么要使用命名空间呢？一些名字易冲突，所以会使用命名空间的方式进行区分，具体来说就是加个前缀。比如C++标准库里面定义了vector容器，自己又写了个vector类，这时名字就冲突了。于是使用标准库里的名字时，都要加上std::的前缀，即std::vector来引用。经常写全名比较繁琐，所以在名字没有冲突的情况下可以添加using namespace std，那么接下去使用标准库里的名字时就可以不用再写std::前缀了

1. /***** namespace_example.cpp *****/
   
2. #include <iostream>
   & t7 p7 M  [- |  a" z& F0 r' D
3. using namespace std;
     a9 G5 d6 ?) r, u8 D* v' ?- t
4. namespace A { //自定义命名空间A
   
5. int x = 1;
   
6. void fun() {
   $ R3 r5 f) n! y8 Y
7.   cout<<"A namespace"<<endl;
   
8. }
   4 X6 C& ]4 b$ w7 h" K( G
9. }
   : m1 M# N9 F% L$ q* b/ e
10. using namespace A; //声明使用命名空间A
    0 V; q1 d; k" ?
11. int main(){
    
12. fun(); //声明使用命名空间A后，可直接使用fun()
    
13. A::x = 3; //将A命名空间下的x重新赋值为3
    
14. cout<<A::x<<endl;
    
15. A::fun();
    
16. return 0;
    
17. }

复制代码

执行下面的指令开始编译

1. g++ namespace_example.cpp -o namespace_example

复制代码

执行./namespace_example后结果如下

1. A namespace
   4 ~' {$ k7 o; D; `3 ~) [
2. 3
   
3. Anamespace

复制代码

二. C++面向对象

, ~. k2 W+ I8 C

面向对象的三大特征是继承，多态和封装

2.1 类和对象

类是C++的核心特性，通常被称为用户定义的类型。类用于指定对象的形式，包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员，函数在一个类中被称为类的成员。从类中实例化对象分两种方法，一种是从栈中实例化对象，一种是从堆中实例化对象

1. /***** class_dog_example.cpp *****/
   4 z3 {/ V6 b) b, g" {" u0 y* ?
2. #include <iostream>
   3 H' T. T( H5 I7 |) |+ o2 }- [
3. #include <string>
   
4. using namespace std;
   
5. 
   * ?6 @4 o0 w+ ?- u4 n  ^6 ?3 w
6. class Dog {  //定义一个类
   ) f* C0 h+ m8 r& a5 ^6 N
7. public:   //访问限定符public(公有的)，不写的话默认是private
   
8. string name;
   
9. int age;
   , x9 y* `/ l1 W& [
10. 
    
11. void run() { //定义一个方法
    ' Y7 E0 c# r9 v* z2 G" W
12.   cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;
    
13. }
    . `# H. W0 W/ R# C+ U: v
14. };
    - _5 w8 K1 K4 K1 Z( f
15. 
    
16. int main() {
    
17. /* 从栈中实例化一个对象dog1 */
    
18. Dog dog1;
    % q& A8 N$ N1 a+ [( {& c6 m+ w7 W
19. dog1.name = "旺财"; //为dog1的成员变量赋值
    . F6 E. ~1 K) d3 t# Z# l) \
20. dog1.age = 2;  //为dog1的成员变量赋值
    
21. dog1.run();   //调用run()方法，打印dog1的相关变量信息
    4 ]6 ^  D7 g2 R7 p' ^+ r
22. /* 从堆中实例化对象，使用关键字new的都是从堆中实例化对象 */
    
23. Dog *dog2 = new Dog();
    + a& l. d) I: A7 `! g2 s9 K0 g
24. if (NULL == dog2) { //从堆中实例化对象需要开辟内存，指针会指向那个内存
    - n0 l- D7 T' B5 X! v6 r
25.   return 0;
    
26. }
    6 A5 S3 l+ W4 S9 W: u5 ]; p
27. dog2->name = "富贵"; //为dog2的成员变量赋值
    
28. dog2->age = 1;   //为dog2的成员变量赋值
    
29. dog2->run();   //调用run()方法，打印dog2的相关变量信息
    ' R5 }) h: _- Z; t9 [+ r  V
30. 
    6 E5 y, H6 f; J+ u* e
31. delete dog2;   //释放内存
    5 y- _- J" {" M+ J2 V
32. dog2 = NULL;   //将dog2重新指向NULL
    9 X( U2 m! c  p  q; G3 M6 W* j: C
33. return 0;
    
34. }
    ; U- X4 I* _6 O. }
35. 执行下面的指令开始编译
    
36. 
    
37. g++ class_dog_example.cpp -o class_dog_example
    : t6 j; X, L5 F% R  f- J
38. 执行./class_dog_example后结果如下
    4 j/ J3 v& B6 h" d- d
39. 
    
40. 小狗的名字是:旺财，年龄是2
    
41. 小狗的名字是:富贵，年龄是1
    
42. ⏩ 构造函数与析构函数
    . _8 z- Y5 g% t2 Y% ?
43. 构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数的特点如下：
    # t; K6 _4 a6 K2 S) `$ Q1 ~
44. 构造函数必须与类名同名
    
45. 
    
46. 可以重载，没有返回类型
    8 f) O- D$ c2 J% e" C  Y
47. 
    4 x2 y6 ^  e' V6 [
48. 构函数在对象结束其生命周期时系统自动执行。析构函数的特点如下：
    + c# N2 m6 H$ K. t  a* b
49. 析构函数的格式为~类名()，调用时释放内存（资源）
    - ?0 d: }  Z% L+ z" Z- I
50. 
    
51. ~类名()不能加参数，没有返回值
    6 ^8 q' j+ ?' F; g
52. 
    / L/ {. k, n6 R' V; `
53. 定义类时， 如果没有定义构造函数和析构函数， 编译器就会生成一个构造函数和析构函数， 只是这个构造和析构函数什么事情也不做。当要使用构造函数和析构函数时就需要自己在类里添加
    ' Y; w! z: V6 y: {( E+ A/ ~
54. 
    
55. /***** structor_example.cpp *****/
    ( [% e& k8 \8 C9 r9 \
56. #include <iostream>
    
57. #include <string>
    
58. using namespace std;
    ! V1 I7 t" `8 B& K
59. 
    - w/ `7 B$ u0 |- R' W" X
60. class Dog {  //定义一个类，并在里面写了构造函数和析构函数
    
61. public:
    ; F& U" n+ K: ?) l0 v' [1 T
62. Dog();
    
63. ~Dog();
    $ \. \# @# _, h. h$ }# o
64. };
    
65. 
    
66. int main() {
    & {8 `: t/ D8 g/ }$ l1 Q/ _
67. Dog dog;  //实例化一个dog对象
    
68. cout<<"构造与析构函数示例"<<endl;
    
69. return 0;
    8 r: }+ ]* ]4 K  E
70. }
    
71. //类的函数可在类里实现，也可在类外实现，在类外实现时需要使用“::”
    # [0 @$ q$ T  K  P7 w
72. Dog::Dog() {
    
73. cout<<"构造函数执行！ "<<endl;
    
74. }
    . f3 q8 s* {" T4 d
75. 
    2 O2 Z' [, g2 _$ |! T+ B1 O8 C5 q
76. Dog::~Dog() {
    2 X5 b1 f/ S# }) V) }  Z
77. cout<<"析构函数执行！ "<<endl;
    2 m$ H' t: ~+ X% A, a- e$ u
78. }

复制代码

执行下面的指令开始编译

1. g++ structor_example.cpp -o structor_example
   " ~+ b7 O: w2 X' N

复制代码

执行./structor_example后结果如下

1. 构造函数执行！
   
2. 构造与析构函数示例
   , j& B' Z. I) l' s
3. 析构函数执行！

复制代码

this指针

每个对象都拥有一个this指针，this指针记录对象的内存地址。this指针是指向类自身数据的指针，简单来说就是指向当前类的当前实例对象。关于类的this指针有以下特点：

• this只能在成员函数中使用，全局函数、静态函数都不能使用this
• this在成员函数的开始前构造，在成员函数的结束后清除
• this指针会因编译器不同而有不同的放置位置。可能是栈，寄存器或者全局变量
  
  

1. /***** this_pointer_example.cpp *****/
   
2. #include <iostream>
   
3. #include <string>
   + ?2 J4 P* D$ G( y
4. using namespace std;
   / Q+ q3 `+ F" |& w
5. 
   
6. class Dog {
   $ e6 e5 o3 x2 l* g
7. public:
   
8. string name;
   
9. void func();
   8 b, c$ m# N8 A; M
10. };
    8 y, I2 T3 |% V$ r! R
11. 
    
12. int main() {
    # r; t$ L" x- |% Z
13. Dog dog;
    3 ]2 U- m1 g8 F7 Z3 q- w9 f
14. dog.func();
    
15. return 0;
    
16. }
    - v: \3 Z, j* j- a
17. //在类的成员函数里使用了this指针， 并指向了类里的成员name
    
18. void Dog::func() {
    
19. this->name = "旺财";
    6 U, A$ V* i6 B1 U' D
20. cout<<"小狗的名字叫： "<<this->name<<endl;
    - o6 v6 w7 M) \, p, R9 \9 m7 Z
21. }

复制代码

执行下面的指令开始编译

1. g++ this_pointer_example.cpp -o this_pointer_example

复制代码

执行./this_pointer_example后结果如下

1. 小狗的名字叫：旺财
   

复制代码

转载自嵌入式攻城狮