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

一. C++新特性

% E& u  ]# N# b5 Y3 u2 d* V- i. o

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

cout语法形式：

1. cout << x << endl;
   ! n( G! K! T/ w& U8 d  G
2. // x 可以是任意数据类型（或表达式）
   + {. c$ a: c0 z* {* r/ M3 R
3. // endl 是换行符，与C里的"\n"效果一样
   
4. cout << x << y << endl;  //多个变量的输出

复制代码

cin 语法形式：

1. cin >> x;  //x可以是任意数据类型
   
2. cin >> x >> y; //多个变量的输入

复制代码

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

1. #include <iostream>
   , {3 i7 v" p, @) R
2. using namespace std;
   
3. int main(){
   7 h9 b2 P, v' w# x. b; }
4. cout << "Hello, World!" << endl;
   # @# K' F& X% {! q" w# n0 ]
5. return 0;
   
6. }

复制代码

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

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

1. /***** namespace_example.cpp *****/
   ( S, Z1 j+ z% m, |& V/ @
2. #include <iostream>
   0 z9 v5 _1 S6 @9 ^; [* z4 b0 @
3. using namespace std;
   9 ?5 ?* s* v, t: p
4. namespace A { //自定义命名空间A
   9 o5 G0 {) L0 j3 \- u6 ~
5. int x = 1;
   
6. void fun() {
   
7.   cout<<"A namespace"<<endl;
   
8. }
   6 B6 f) c% e; q2 [4 I/ W8 A* l
9. }
   ) C* Y5 n. f4 Q) S2 k# T; x
10. using namespace A; //声明使用命名空间A
    6 U/ x* H. y% G
11. int main(){
    
12. fun(); //声明使用命名空间A后，可直接使用fun()
    4 {7 P' L# m) f. ^# M1 y
13. A::x = 3; //将A命名空间下的x重新赋值为3
    
14. cout<<A::x<<endl;
    4 |+ m; k3 L6 u5 m8 H
15. A::fun();
    / |5 M. p: U& s; M5 [. Q9 l
16. return 0;
    
17. }

复制代码

执行下面的指令开始编译

1. g++ namespace_example.cpp -o namespace_example

复制代码

执行./namespace_example后结果如下

1. A namespace
   1 O: _& A: M6 e7 Y6 t1 V
2. 3
   
3. Anamespace

复制代码

二. C++面向对象

  ~; C( w% W) X4 ]' o/ P

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

2.1 类和对象

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

6 H: i% j, T, M+ k" y

1. /***** class_dog_example.cpp *****/
     k3 }# d: @: M2 N  r$ i1 G
2. #include <iostream>
     s- Y, \' J* u6 }
3. #include <string>
   , H6 R* G2 ?, {$ u. A! v4 J
4. using namespace std;
   : j0 j: ?  x& s- M. @
5. 
     y) N% A" r1 {( m" I6 A
6. class Dog {  //定义一个类
   7 Q/ s% T. |% w$ v9 p
7. public:   //访问限定符public(公有的)，不写的话默认是private
   4 i4 A1 z, }9 k- O7 v
8. string name;
   " T0 R) X; Z3 B
9. int age;
   9 S1 l' y1 c. g7 t( p( V
10. 
    # V0 K) y2 R4 f+ Z
11. void run() { //定义一个方法
    
12.   cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;
    
13. }
    $ ]. N: a. q- M5 x8 u# R* X' r
14. };
    
15. 
    " k# j8 [8 {2 w1 ]2 D6 u9 V1 k
16. int main() {
    % _) G; U8 E4 Q: F
17. /* 从栈中实例化一个对象dog1 */
    " f; p  D* [' M; z
18. Dog dog1;
    0 q  c5 m7 J0 f2 K! s
19. dog1.name = "旺财"; //为dog1的成员变量赋值
    , B/ x3 T5 X$ V+ _. @: j; s! j/ g9 P
20. dog1.age = 2;  //为dog1的成员变量赋值
      D) P/ k! e2 _0 o
21. dog1.run();   //调用run()方法，打印dog1的相关变量信息
    2 ]- N; j+ U7 {0 [. C: H
22. /* 从堆中实例化对象，使用关键字new的都是从堆中实例化对象 */
    - K" v. V7 O' _- R
23. Dog *dog2 = new Dog();
    
24. if (NULL == dog2) { //从堆中实例化对象需要开辟内存，指针会指向那个内存
    
25.   return 0;
    
26. }
    
27. dog2->name = "富贵"; //为dog2的成员变量赋值
    
28. dog2->age = 1;   //为dog2的成员变量赋值
    ( ]7 ^8 K' F* r( h7 B+ O3 @, d: y
29. dog2->run();   //调用run()方法，打印dog2的相关变量信息
    5 P- ~* C. q/ P0 h/ F5 C( K2 t
30. 
    $ Q& b  i, G1 w0 k$ s
31. delete dog2;   //释放内存
    
32. dog2 = NULL;   //将dog2重新指向NULL
    ; Q7 ]' i1 D/ e( F' Y: J
33. return 0;
    7 b; ?$ O! |) y& `  o8 U8 Z
34. }
    
35. 执行下面的指令开始编译
    
36. 
    
37. g++ class_dog_example.cpp -o class_dog_example
    
38. 执行./class_dog_example后结果如下
    
39. 
    
40. 小狗的名字是:旺财，年龄是2
    
41. 小狗的名字是:富贵，年龄是1
    ' ~( |( T2 m" _2 }& F
42. ⏩ 构造函数与析构函数
    ; w7 P. T9 }# H4 Y" P( z# v
43. 构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数的特点如下：
    1 t* \3 G; s1 n/ @; @* r6 f
44. 构造函数必须与类名同名
    " b5 r& g- V$ B
45. 
    8 \( h# p* P3 g
46. 可以重载，没有返回类型
    0 p6 E2 s% b8 z( `( c% N2 _
47. 
    / x0 I( \; c, L2 V8 b6 G
48. 构函数在对象结束其生命周期时系统自动执行。析构函数的特点如下：
    
49. 析构函数的格式为~类名()，调用时释放内存（资源）
    ' N% k% K5 q& T$ w
50. 
    
51. ~类名()不能加参数，没有返回值
    
52. 
    
53. 定义类时， 如果没有定义构造函数和析构函数， 编译器就会生成一个构造函数和析构函数， 只是这个构造和析构函数什么事情也不做。当要使用构造函数和析构函数时就需要自己在类里添加
    
54. 
    
55. /***** structor_example.cpp *****/
    
56. #include <iostream>
    : n( S2 R+ o9 g8 i: i9 \4 |. J
57. #include <string>
    
58. using namespace std;
    ; E& v/ ]# k; g5 m: l
59. 
    
60. class Dog {  //定义一个类，并在里面写了构造函数和析构函数
    
61. public:
    - Q& N# o& Z5 S
62. Dog();
    ! v% |9 {) i7 L( m8 Z! c
63. ~Dog();
    * D! Q2 C' m8 |( S, }0 H5 Y
64. };
    6 k4 J, f% c4 m3 T
65. 
    
66. int main() {
    8 N; D. _! K5 E- }
67. Dog dog;  //实例化一个dog对象
    
68. cout<<"构造与析构函数示例"<<endl;
    
69. return 0;
    " a; a3 f6 P  V0 X6 @- m
70. }
    * \7 i9 b& n- K+ w# n" ^
71. //类的函数可在类里实现，也可在类外实现，在类外实现时需要使用“::”
    7 D: Y5 s$ F( q' O2 B2 e
72. Dog::Dog() {
    # X( y0 q- H8 X. n! ]3 j2 |, J
73. cout<<"构造函数执行！ "<<endl;
    
74. }
    3 @3 g5 b# P& v
75. 
    
76. Dog::~Dog() {
    
77. cout<<"析构函数执行！ "<<endl;
    
78. }

复制代码

执行下面的指令开始编译

1. g++ structor_example.cpp -o structor_example
   

复制代码

执行./structor_example后结果如下

1. 构造函数执行！
   - [7 m" m7 {+ T  J6 B. g
2. 构造与析构函数示例
   
3. 析构函数执行！

复制代码

this指针

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

1 P) d( ~0 \2 f6 [# p6 i

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

1. /***** this_pointer_example.cpp *****/
   * K( w% P% j* ]
2. #include <iostream>
   
3. #include <string>
   3 T$ F4 X- y/ ~/ `/ [6 \2 n
4. using namespace std;
   
5. 
   8 t, r: |- @- V' {/ ?
6. class Dog {
   # O+ d+ Y* {/ s8 M9 u0 g
7. public:
   - d% r! \; ^% B' p  u$ s2 ?
8. string name;
   
9. void func();
   
10. };
    
11. 
    " z2 e8 x* N; y& n: E( Y7 `" B
12. int main() {
    ' R& ~  q0 p$ l2 }2 C
13. Dog dog;
    
14. dog.func();
    / C/ |. M& f! D; J5 t: |
15. return 0;
    
16. }
    ; Y4 [0 E" t4 C& m" S% k
17. //在类的成员函数里使用了this指针， 并指向了类里的成员name
    5 L$ f, y4 I1 d6 v4 ?# k  h& s9 V
18. void Dog::func() {
    ' e; `3 p) O$ B7 G$ i0 w2 U) }
19. this->name = "旺财";
    - x+ K; a+ |  D% a
20. cout<<"小狗的名字叫： "<<this->name<<endl;
    
21. }

复制代码

执行下面的指令开始编译

1. g++ this_pointer_example.cpp -o this_pointer_example

复制代码

执行./this_pointer_example后结果如下

1. 小狗的名字叫：旺财
   % d# z" x: K4 T

复制代码

. |; o& S8 Y; A8 }

转载自嵌入式攻城狮