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

一. C++新特性

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

cout语法形式：

1. cout << x << endl;
   ; u5 p: f0 S, C8 A3 p; a
2. // x 可以是任意数据类型（或表达式）
   
3. // endl 是换行符，与C里的"\n"效果一样
   6 C1 b: L( \4 w" M3 i
4. cout << x << y << endl;  //多个变量的输出

复制代码

cin 语法形式：

1. cin >> x;  //x可以是任意数据类型
   * b+ K, R5 z- y2 J9 x9 F: x
2. cin >> x >> y; //多个变量的输入

复制代码

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

1. #include <iostream>
   
2. using namespace std;
   ! Q& p# D5 }5 p3 l$ c7 u5 s
3. int main(){
   * Z1 f1 A  ?; B3 e
4. cout << "Hello, World!" << endl;
   
5. return 0;
   3 \5 @8 N$ {2 j- L/ g
6. }

复制代码

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

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

1. /***** namespace_example.cpp *****/
   * |0 X0 H; L$ j; B( H- y
2. #include <iostream>
   
3. using namespace std;
   , r3 J. R3 h4 a$ Y3 r) h1 W! d
4. namespace A { //自定义命名空间A
   
5. int x = 1;
   3 n; ]' Y4 k% O+ N' P/ D* f
6. void fun() {
   
7.   cout<<"A namespace"<<endl;
   7 F, T8 O, T8 k, M
8. }
   
9. }
   / z' c% w7 @& R
10. using namespace A; //声明使用命名空间A
    6 ^" h2 |; p& r3 i' Y1 U( Y
11. int main(){
    
12. fun(); //声明使用命名空间A后，可直接使用fun()
    
13. A::x = 3; //将A命名空间下的x重新赋值为3
    
14. cout<<A::x<<endl;
    ' v/ g2 V8 L' X- T
15. A::fun();
    2 `2 M+ N7 V) j9 O& J! y
16. return 0;
    
17. }

复制代码

执行下面的指令开始编译

1. g++ namespace_example.cpp -o namespace_example

复制代码

执行./namespace_example后结果如下

1. A namespace
   
2. 3
   6 [' B; P0 @. I; P" f, N9 \6 k
3. Anamespace

复制代码

二. C++面向对象

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

2.1 类和对象

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

* V. j: [7 Y/ `2 Z

1. /***** class_dog_example.cpp *****/
   " |3 X) k! ^; |+ p
2. #include <iostream>
   
3. #include <string>
   
4. using namespace std;
   
5. 
   & V" ?1 H8 N! ~' f
6. class Dog {  //定义一个类
   3 h4 O& t" ?2 R" L5 G0 @% S' M# I( {
7. public:   //访问限定符public(公有的)，不写的话默认是private
   
8. string name;
   : z  e, w; w- h
9. int age;
   
10. 
    ( d) K- q7 S+ e5 k
11. void run() { //定义一个方法
    
12.   cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;
    
13. }
    
14. };
    $ ^, R$ z# m% O7 c# y
15. 
    / B9 ]1 D7 q1 D9 x; d' M
16. int main() {
    
17. /* 从栈中实例化一个对象dog1 */
    
18. Dog dog1;
    " U: F4 s" L) d; E/ J
19. dog1.name = "旺财"; //为dog1的成员变量赋值
    
20. dog1.age = 2;  //为dog1的成员变量赋值
    1 @0 ?$ ?2 J/ H
21. dog1.run();   //调用run()方法，打印dog1的相关变量信息
    . c/ q& @" k1 ~
22. /* 从堆中实例化对象，使用关键字new的都是从堆中实例化对象 */
    7 T! ?! ?  v) _4 K6 ?3 S
23. Dog *dog2 = new Dog();
    9 `2 W0 |5 \# Z4 _+ Y
24. if (NULL == dog2) { //从堆中实例化对象需要开辟内存，指针会指向那个内存
    5 c7 H4 o" p. j/ n' ^6 v9 q
25.   return 0;
    ) w8 ]6 L! u3 \
26. }
    2 R- o4 b" u+ L3 B+ @0 f$ n5 j
27. dog2->name = "富贵"; //为dog2的成员变量赋值
    - Z! [+ Z2 p" p+ {$ z
28. dog2->age = 1;   //为dog2的成员变量赋值
    
29. dog2->run();   //调用run()方法，打印dog2的相关变量信息
    
30. 
    , ^: U& t' ?( T) H4 @, A
31. delete dog2;   //释放内存
    
32. dog2 = NULL;   //将dog2重新指向NULL
    
33. return 0;
    
34. }
    5 z% p( t& V$ k6 E3 }# R* |/ Z
35. 执行下面的指令开始编译
    5 W0 X; k4 y# a& A: k; q9 _# x
36. 
    8 g3 S1 o$ }8 ^7 _& g
37. g++ class_dog_example.cpp -o class_dog_example
    
38. 执行./class_dog_example后结果如下
    
39. 
    
40. 小狗的名字是:旺财，年龄是2
    - I" _  m: a6 v3 l2 f
41. 小狗的名字是:富贵，年龄是1
    
42. ⏩ 构造函数与析构函数
    , e4 j# X. r. c3 t/ ?
43. 构造函数在对象实例化时被系统自动调用，仅且调用一次。构造函数的特点如下：
    
44. 构造函数必须与类名同名
    3 O/ m  f/ R; j& i, {) ?. C
45. 
    , X2 J! z+ X+ c
46. 可以重载，没有返回类型
    1 e5 c8 V0 `: M
47. 
    6 Q/ {# x; e+ S( t  H  Y$ h/ x
48. 构函数在对象结束其生命周期时系统自动执行。析构函数的特点如下：
    
49. 析构函数的格式为~类名()，调用时释放内存（资源）
    
50. 
    
51. ~类名()不能加参数，没有返回值
    . U1 j. L3 ]3 z! i1 t. [2 B$ {7 f; A5 O
52. 
    + `8 O5 s& o0 c! t
53. 定义类时， 如果没有定义构造函数和析构函数， 编译器就会生成一个构造函数和析构函数， 只是这个构造和析构函数什么事情也不做。当要使用构造函数和析构函数时就需要自己在类里添加
    
54. 
    
55. /***** structor_example.cpp *****/
      W4 o3 l+ a0 r
56. #include <iostream>
    & V5 f& x2 Q* S% f; u( J
57. #include <string>
    $ h: R) i  C; E$ d7 b2 i
58. using namespace std;
    9 J/ m' t9 j* B( i2 X/ o
59. 
    
60. class Dog {  //定义一个类，并在里面写了构造函数和析构函数
    3 o; ?0 u/ \9 w5 e% `% e' q1 S
61. public:
    
62. Dog();
    " u$ c# @* P0 h" H. T5 D
63. ~Dog();
    $ a3 d  |5 e& f' G+ Q1 ~; l
64. };
    ' F6 r( C& J) J* b! h3 C
65. 
    ) T1 P3 A1 p7 J. _3 O/ ?1 M
66. int main() {
    
67. Dog dog;  //实例化一个dog对象
    1 {# Q2 B% `6 \$ Y, {
68. cout<<"构造与析构函数示例"<<endl;
    7 T+ s$ u* y2 Z  ^  J' e) t
69. return 0;
    
70. }
    $ q/ v: s9 x; L5 Y8 I- ~
71. //类的函数可在类里实现，也可在类外实现，在类外实现时需要使用“::”
    
72. Dog::Dog() {
    
73. cout<<"构造函数执行！ "<<endl;
    0 `* l  L1 }* Y( ^0 R
74. }
    
75. 
    ; `( t! a. }& V7 H  ]
76. Dog::~Dog() {
    
77. cout<<"析构函数执行！ "<<endl;
    - l7 _, J; A. z' h0 W. ]  n+ c/ j
78. }

复制代码

执行下面的指令开始编译

1. g++ structor_example.cpp -o structor_example
   " E, s/ n6 j: |% h( e

复制代码

执行./structor_example后结果如下

1. 构造函数执行！
     X( f: ^9 R) w* [
2. 构造与析构函数示例
   3 f; W, ]2 U& |
3. 析构函数执行！

复制代码

this指针

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

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

1. /***** this_pointer_example.cpp *****/
   
2. #include <iostream>
   / U  q& f8 J) G- X2 G- X' Z
3. #include <string>
   
4. using namespace std;
   
5. 
   
6. class Dog {
   & r7 N; x* A. F' K1 m: V" c( x
7. public:
   % m: k: q" _0 X$ i+ M1 u) ~( Q9 q
8. string name;
   
9. void func();
   
10. };
    : u" R( S* _6 V  H2 u/ ~2 u  H3 j
11. 
    
12. int main() {
    
13. Dog dog;
    ; U1 z; Q% J1 B# V7 W
14. dog.func();
    
15. return 0;
    
16. }
    
17. //在类的成员函数里使用了this指针， 并指向了类里的成员name
    
18. void Dog::func() {
    
19. this->name = "旺财";
    - L6 h2 j( z. }
20. cout<<"小狗的名字叫： "<<this->name<<endl;
    
21. }

复制代码

执行下面的指令开始编译

1. g++ this_pointer_example.cpp -o this_pointer_example

复制代码

执行./this_pointer_example后结果如下

1. 小狗的名字叫：旺财
   

复制代码

$ X! ]3 k# _# r6 x& ?) ?' V

转载自嵌入式攻城狮