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 可以是任意数据类型（或表达式）
     _4 L; P. T  a/ j- q3 r
3. // endl 是换行符，与C里的"\n"效果一样
   
4. cout << x << y << endl;  //多个变量的输出

复制代码

cin 语法形式：

1. cin >> x;  //x可以是任意数据类型
   ) g$ |9 `3 L. J& X
2. cin >> x >> y; //多个变量的输入

复制代码

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

1. #include <iostream>
   
2. using namespace std;
   8 y* Q0 u) S0 ~4 A& d
3. int main(){
   2 s3 ?% a/ m# J2 k9 X# K0 f! f+ [) I
4. cout << "Hello, World!" << endl;
   
5. return 0;
   
6. }

复制代码

上面程序中，头文件要写成iostream，因为是标准输入输出流；带".h"的是非标准输入输出流。using是编译指令，声明当前命名空间的关键词，可理解成使用命名空间std，因为cin和cout都是属于std命名空间的，所以使用时须加上using namespace std，也可以写成std::cin和std::cout，其中 :: 表示作用域
( C: H' ]: \  w' e

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

1. /***** namespace_example.cpp *****/
   
2. #include <iostream>
   9 f( p. M& z" ^
3. using namespace std;
   ) S5 W0 {; m1 }( p" l! o
4. namespace A { //自定义命名空间A
   ) X+ z/ u. {7 K4 Y
5. int x = 1;
   3 P! p# P9 F; j. [1 [* I  i7 }
6. void fun() {
   
7.   cout<<"A namespace"<<endl;
   
8. }
   " Y& K5 @# n/ [. s% s
9. }
   - F0 O. x( N9 b( p
10. using namespace A; //声明使用命名空间A
    
11. int main(){
    2 P7 U/ t# F% J% F3 c4 s/ T
12. fun(); //声明使用命名空间A后，可直接使用fun()
    $ ?* ^* k+ w$ H/ i/ ^
13. A::x = 3; //将A命名空间下的x重新赋值为3
    . b4 u6 B, _7 L7 }! W2 D. k
14. cout<<A::x<<endl;
    0 h: I$ M; D( S
15. A::fun();
    
16. return 0;
    
17. }

复制代码

执行下面的指令开始编译

1. g++ namespace_example.cpp -o namespace_example

复制代码

执行./namespace_example后结果如下

1. A namespace
   3 b& k# E- D/ m8 c# s
2. 3
   
3. Anamespace

复制代码

二. C++面向对象

0 l% b5 y; T) W7 d4 B: o# ~8 l

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

2.1 类和对象

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

; e1 Z  i- F5 w6 `3 q

1. /***** class_dog_example.cpp *****/
   2 D' \6 v6 j, |) U( ?5 F
2. #include <iostream>
   7 x9 ]* \& ~$ _
3. #include <string>
   / n# q$ k/ W0 ~+ D3 d, X) D4 g
4. using namespace std;
   8 D8 w3 Z- p2 L! k' Y7 p+ \- E
5. 
   + H: [  J5 m* Q  ?) B  \1 S$ \3 r+ [7 @: f
6. class Dog {  //定义一个类
   ! C; J9 X$ j& T6 Z: x$ Y+ f% i
7. public:   //访问限定符public(公有的)，不写的话默认是private
   # N. r! }% k  u
8. string name;
   
9. int age;
   
10. 
    . u5 r% ?0 m$ [6 o* G' [
11. void run() { //定义一个方法
    ! T5 @% h4 X* r' w6 @" J
12.   cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;
    
13. }
    
14. };
    ( I! b# x( `4 O- Q
15. 
    7 t5 r# H9 T3 b+ g9 ^! U+ B( j
16. int main() {
      X6 l0 }0 ~' k" O
17. /* 从栈中实例化一个对象dog1 */
    5 g9 ]; {% {9 M6 F/ l
18. Dog dog1;
    9 b# e2 a4 Z5 b* @6 d, z
19. dog1.name = "旺财"; //为dog1的成员变量赋值
    3 O8 ~/ @+ c# d0 j$ n( ?3 \
20. dog1.age = 2;  //为dog1的成员变量赋值
    
21. dog1.run();   //调用run()方法，打印dog1的相关变量信息
    # E3 [1 G, H' s1 E8 _6 I
22. /* 从堆中实例化对象，使用关键字new的都是从堆中实例化对象 */
    
23. Dog *dog2 = new Dog();
    
24. if (NULL == dog2) { //从堆中实例化对象需要开辟内存，指针会指向那个内存
    
25.   return 0;
    " h. L8 U8 r2 k# W' m  e# B2 G, L9 `
26. }
    
27. dog2->name = "富贵"; //为dog2的成员变量赋值
    4 y! Y& N! w2 N4 H+ S7 P
28. dog2->age = 1;   //为dog2的成员变量赋值
    4 j9 N/ ~3 u* m/ L) X' V- ]% I7 E
29. dog2->run();   //调用run()方法，打印dog2的相关变量信息
    ! ^/ Z% J. x2 ^( i: Y
30. 
    
31. delete dog2;   //释放内存
    
32. dog2 = NULL;   //将dog2重新指向NULL
    
33. return 0;
    
34. }
    
35. 执行下面的指令开始编译
    3 |$ g: D7 [3 W" a3 ?$ P, u
36. 
    
37. g++ class_dog_example.cpp -o class_dog_example
    
38. 执行./class_dog_example后结果如下
    " |7 v# H$ E; D2 Y3 z4 F' i
39. 
    
40. 小狗的名字是:旺财，年龄是2
    + g, k$ V7 D) Y0 K
41. 小狗的名字是:富贵，年龄是1
    - E1 }& ~+ ?# A4 I. J
42. ⏩ 构造函数与析构函数
    $ {. g9 A# J& b2 j
43. 构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数的特点如下：
    + L! C/ }; ^3 x0 D
44. 构造函数必须与类名同名
    / V+ @9 e- t) |4 S
45. 
    
46. 可以重载，没有返回类型
    6 P- v7 ?& ~8 c' p" u! V, K' [3 C
47. 
    8 i# _0 W) H( U) q! I" u
48. 构函数在对象结束其生命周期时系统自动执行。析构函数的特点如下：
    
49. 析构函数的格式为~类名()，调用时释放内存（资源）
    
50. 
    4 h* m% T# j, c9 i8 W
51. ~类名()不能加参数，没有返回值
    
52. 
    
53. 定义类时， 如果没有定义构造函数和析构函数， 编译器就会生成一个构造函数和析构函数， 只是这个构造和析构函数什么事情也不做。当要使用构造函数和析构函数时就需要自己在类里添加
    ; Y) s% [- X+ Z
54. 
    
55. /***** structor_example.cpp *****/
    
56. #include <iostream>
    ) L% }8 ]& ]8 ~& X
57. #include <string>
    
58. using namespace std;
    
59. 
    $ ~! `$ ^- R/ [; ^$ ^' c! T
60. class Dog {  //定义一个类，并在里面写了构造函数和析构函数
    
61. public:
    4 X8 J* n& e8 o0 B. `
62. Dog();
    + @3 x, _0 V* M! R6 c% V. `
63. ~Dog();
    
64. };
    
65. 
    
66. int main() {
    
67. Dog dog;  //实例化一个dog对象
    
68. cout<<"构造与析构函数示例"<<endl;
    4 Y# _& G  U& h4 S" I$ `$ Z' T0 \
69. return 0;
    3 h) k" [' a& z: g
70. }
    
71. //类的函数可在类里实现，也可在类外实现，在类外实现时需要使用“::”
    
72. Dog::Dog() {
    
73. cout<<"构造函数执行！ "<<endl;
    
74. }
      ~1 L- I# ?4 }9 ]  m4 D
75. 
    0 y5 I) @8 [# x! G, ~
76. Dog::~Dog() {
    
77. cout<<"析构函数执行！ "<<endl;
    
78. }

复制代码

执行下面的指令开始编译

1. g++ structor_example.cpp -o structor_example
   

复制代码

执行./structor_example后结果如下

1. 构造函数执行！
   ' N3 r1 D% Z' Q/ g6 g& [3 t
2. 构造与析构函数示例
   + |# S* u2 Y  O/ W. j1 w
3. 析构函数执行！

复制代码

this指针

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

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

1. /***** this_pointer_example.cpp *****/
   7 o8 l+ }3 ~" u
2. #include <iostream>
   
3. #include <string>
     ?! T* s7 P* U2 D* E# U0 B% m
4. using namespace std;
   $ P& s7 |0 ], ^
5. 
   
6. class Dog {
   
7. public:
   
8. string name;
   # w8 y' s& W3 ]8 C
9. void func();
   . y7 q. v9 \2 y) H! J, g3 g( _2 i% M
10. };
    
11. 
    
12. int main() {
    # a8 }1 A+ b; L% d7 ?3 y
13. Dog dog;
    9 e/ u4 }3 A5 q: I8 l# d" o
14. dog.func();
    ) U+ `6 n! S+ e/ q9 C
15. return 0;
    , \+ V: b- T0 G. P* X7 `* b
16. }
    * X5 A3 ~" |5 p8 ]: V
17. //在类的成员函数里使用了this指针， 并指向了类里的成员name
    
18. void Dog::func() {
    
19. this->name = "旺财";
    + f- T; J! }5 F( {- ]' k9 q6 d
20. cout<<"小狗的名字叫： "<<this->name<<endl;
    : i0 S6 N- |5 p% W; c& R8 G
21. }

复制代码

执行下面的指令开始编译

1. g++ this_pointer_example.cpp -o this_pointer_example

复制代码

执行./this_pointer_example后结果如下

1. 小狗的名字叫：旺财
   

复制代码

' P% R6 S" o, t3 F3 p/ M2 \, Q

转载自嵌入式攻城狮