|
TouchGFX是一个基于STM32硬件,由C++写成的软件框架,所以有必要对C++基础有一定的了解 一. C++新特性
2 x7 e" w0 ]/ \7 }! G
C语言里,变量初始化必须在程序的前面,而C++则可以随用随定义。C++也可以直接初始化,比如 int x(100),这样就直接赋值 x=100C++的输入输出方式:以cin和cout代替了C语言里的scanf和printf cout语法形式: - cout << x << endl;
1 y4 N& p% u8 f" i: e - // x 可以是任意数据类型(或表达式)
0 x. i5 q- U, F: l% N - // endl 是换行符,与C里的"\n"效果一样
' f% c; v9 m: M T( q1 u" t - cout << x << y << endl; //多个变量的输出
复制代码cin 语法形式: - cin >> x; //x可以是任意数据类型
( o: q' ~3 F: S u! i - cin >> x >> y; //多个变量的输入
复制代码C++的命名空间 namespace:using namespace std; - #include <iostream>
! F: M5 g9 s% a0 r - using namespace std;. B% I4 l! d& [" D" C% r4 G
- int main(){
' k( U1 o$ s( Z# a+ E2 T; Z# X' S) Y - cout << "Hello, World!" << endl;
! D. ~7 q0 o* r - return 0;
2 {0 t! _* p2 y# Z8 K0 d: o$ Q - }
复制代码上面程序中,头文件要写成iostream,因为是标准输入输出流;带".h"的是非标准输入输出流。using是编译指令,声明当前命名空间的关键词,可理解成使用命名空间std,因为cin和cout都是属于std命名空间的,所以使用时须加上using namespace std,也可以写成std::cin和std::cout,其中 :: 表示作用域
3 ?0 Y4 |# R" m8 B为什么要使用命名空间呢?一些名字易冲突,所以会使用命名空间的方式进行区分,具体来说就是加个前缀。比如C++标准库里面定义了vector容器,自己又写了个vector类,这时名字就冲突了。于是使用标准库里的名字时,都要加上std::的前缀,即std::vector来引用。经常写全名比较繁琐,所以在名字没有冲突的情况下可以添加using namespace std,那么接下去使用标准库里的名字时就可以不用再写std::前缀了 - /***** namespace_example.cpp *****/8 t# R4 X/ |3 ^' p) C
- #include <iostream>
4 p1 @* g* K5 E% r. } - using namespace std;4 M# K. t7 p3 s; o
- namespace A { //自定义命名空间A
" L9 l' }5 L( @/ U% M - int x = 1;
& d+ |' g8 Y& z! o# y" }$ p - void fun() {8 @/ }( L2 i7 n7 x1 N
- cout<<"A namespace"<<endl;
$ D6 n; r. P" I5 M - }( M5 M5 @# y) n8 ], w5 ^6 |: K( e
- }
% e2 S& M2 N \* I$ o# y) } - using namespace A; //声明使用命名空间A: E6 k( e" G. Q! T8 R
- int main(){9 {/ ?$ ]7 { t- j
- fun(); //声明使用命名空间A后,可直接使用fun()8 _3 q. V5 {6 z+ U" }# h; i1 d
- A::x = 3; //将A命名空间下的x重新赋值为3 M T# r" P; d" a7 m! u3 x3 ~% g) a
- cout<<A::x<<endl;- p" d9 v& m/ i S: \1 h- }. J
- A::fun();. D' |6 W/ @9 l* { }! c m5 @, d% Y. o* T
- return 0;
0 {+ H9 p2 f! A: `6 A, q) ~; P - }
复制代码执行下面的指令开始编译 - g++ namespace_example.cpp -o namespace_example
复制代码执行./namespace_example后结果如下 - A namespace
0 s" Z% l/ _: X+ r - 3
* C/ w! H. W# E4 g$ X" R& U& [ - Anamespace
复制代码二. C++面向对象
7 K9 i& c" Z+ W& s$ s. H0 o' X1 |
面向对象的三大特征是继承,多态和封装 2.1 类和对象 类是C++的核心特性,通常被称为用户定义的类型。类用于指定对象的形式,包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员,函数在一个类中被称为类的成员。从类中实例化对象分两种方法,一种是从栈中实例化对象,一种是从堆中实例化对象 ' i8 e+ _- t/ D
- /***** class_dog_example.cpp *****/3 z3 M2 r8 w1 q" L2 `' [! a. l
- #include <iostream>
* } A1 f# ?& {4 d$ y( @ - #include <string>
/ n" a4 D, v4 Q$ B" _( R - using namespace std;
/ c3 [+ B- e1 j9 ?! h4 X+ Z - ; K$ X6 w6 v) R# }' g8 T( C
- class Dog { //定义一个类' L; U& ~2 Q o2 e6 s E& E: c- `/ I" v& v% k
- public: //访问限定符public(公有的),不写的话默认是private+ h7 ?6 Y$ E6 t& {& J! K7 c
- string name;# V: L; q6 K% t' Q
- int age;
* b8 D: k- b0 V. }# Z& o: s -
$ q( t7 Z$ t5 P - void run() { //定义一个方法$ E I- x2 f( @2 ?" F* C8 F+ b: a
- cout<<"小狗的名字是:"<<name<<","<<"年龄是"<<age<<endl;2 F y Z$ R5 J( f7 ]: h
- }8 d: B7 o. U9 k0 r3 f. y0 w9 e: l$ D
- };: {5 V" }4 [$ s& u0 g; t. j8 l j
- " t& J2 p! k3 t. Q" Y
- int main() {" `4 y2 c @& I9 G, E4 C: @, ^ z
- /* 从栈中实例化一个对象dog1 */
h# z' d/ `* _9 R1 r - Dog dog1;
: s/ s& {1 S$ B$ _ - dog1.name = "旺财"; //为dog1的成员变量赋值$ P) ]) n5 Y9 \: K+ C! I
- dog1.age = 2; //为dog1的成员变量赋值
3 P4 y/ Z+ Y4 \ {; j; _ {& g, v - dog1.run(); //调用run()方法,打印dog1的相关变量信息
/ i" a6 y! E8 I# d - /* 从堆中实例化对象,使用关键字new的都是从堆中实例化对象 */
# K8 i' Z) l( q0 {- j' P5 _0 G - Dog *dog2 = new Dog();
3 [0 b6 J: J, G4 V - if (NULL == dog2) { //从堆中实例化对象需要开辟内存,指针会指向那个内存
- ~3 [2 f0 l' J; j3 l* x) c - return 0;( X, i+ Z3 [0 Z1 X
- }. C1 k+ ?* ]* ], y0 L& ^0 u" Y
- dog2->name = "富贵"; //为dog2的成员变量赋值
; j7 H- K v2 H h% U- Q# a5 b5 z - dog2->age = 1; //为dog2的成员变量赋值
& I! @9 k, b+ b6 ?6 y - dog2->run(); //调用run()方法,打印dog2的相关变量信息2 F& `$ d. T2 a$ ]2 G# A* i
+ B5 e" f5 C$ \# o- delete dog2; //释放内存
" S* k2 Q0 n, f( b. r - dog2 = NULL; //将dog2重新指向NULL% v% o0 S1 g3 B9 I
- return 0;
" A$ _( I/ b) o+ D; u* w0 L" X - }
9 w$ z6 O- N: L$ o# [ - 执行下面的指令开始编译
3 |& B/ T; N7 x% d: u+ R - % q; E: P* C2 [* n1 ~) F& w) ]+ i, ], c
- g++ class_dog_example.cpp -o class_dog_example
! @ @0 @! }( V. f - 执行./class_dog_example后结果如下
; v0 l! `$ G( D3 s; P Z# J) S - 6 X$ ?; R$ P* [' Y" Y2 H% u/ Q
- 小狗的名字是:旺财,年龄是2/ p5 ^! w; N0 V/ c0 a# t& ^
- 小狗的名字是:富贵,年龄是14 H7 U- ?# f" z2 ^$ S6 r
- ⏩ 构造函数与析构函数 O! o6 C0 A! y% ^( s& p
- 构造函数在对象实例化时被系统自动调用,仅且调用一次。构造函数的特点如下:6 J( t9 d2 V. P" l
- 构造函数必须与类名同名; ~ D0 K+ {' J {
3 o1 y6 `- s9 s3 F9 }- 可以重载,没有返回类型- N4 a! \! T5 g7 B# s) h' `, K# I
- 8 b- ]4 b" W4 K2 a' b7 l% z
- 构函数在对象结束其生命周期时系统自动执行。析构函数的特点如下:
: k: h F: p. H& V# t/ ^- ~ - 析构函数的格式为~类名(),调用时释放内存(资源)
( V9 o( i1 W& ^
$ p: n0 V! A$ r( `9 s6 w- ~类名()不能加参数,没有返回值
+ Q8 q0 V0 o5 `' B$ X. q" L( i
# N- D2 V M; R& N0 P* Q/ L! @8 ]- 定义类时, 如果没有定义构造函数和析构函数, 编译器就会生成一个构造函数和析构函数, 只是这个构造和析构函数什么事情也不做。当要使用构造函数和析构函数时就需要自己在类里添加
! v9 @/ a! E4 e8 Q( i! i. k - 4 s$ S7 P2 x4 Q& c$ X
- /***** structor_example.cpp *****/+ C! K! N! y! D6 [
- #include <iostream>4 v8 x/ g* g& w6 C
- #include <string>
7 T' b. k$ Q) { - using namespace std;
! M6 C+ k! Z l, w0 L2 X
: d& q. C1 ^9 O- class Dog { //定义一个类,并在里面写了构造函数和析构函数
$ I$ Y: F$ p: H# Z; w4 W9 ? - public:
) o2 `# A8 }$ x$ Z' J - Dog();2 \9 [8 C+ c8 d# `
- ~Dog();) Z: r4 L: A( v6 i. Z9 m5 B" ~- F
- };* B) c# a& m/ p4 H! h" |7 p% M: o9 ]0 M
- # }* _" e+ ]% _
- int main() {! k, g3 n+ I5 |
- Dog dog; //实例化一个dog对象: q9 x7 p7 R# Z9 Q; l& [8 n1 \
- cout<<"构造与析构函数示例"<<endl;
2 V2 h1 ]3 W0 e$ u - return 0;
+ A, y+ q ]! a0 a0 h; Y, k! `. W) v - }
) |' E& n( o, U7 k1 D5 C- j - //类的函数可在类里实现,也可在类外实现,在类外实现时需要使用“::”
$ c8 u3 t, d+ F - Dog::Dog() {
9 Z4 Y. g3 `) {7 \* I - cout<<"构造函数执行! "<<endl;$ V1 ?9 e, V4 \- Q1 w0 W
- }& }9 Z: ~$ u; @. R: a
/ i. y2 Q0 A1 L9 G# j& W( N- Dog::~Dog() {
( |5 T% J4 S2 B, b5 a- r - cout<<"析构函数执行! "<<endl;: Z- q$ f' c- W0 Y* `+ f
- }
复制代码执行下面的指令开始编译 - g++ structor_example.cpp -o structor_example
5 y) ]+ V% q h
复制代码执行./structor_example后结果如下 - 构造函数执行!
) J# c. s" Q1 F1 k) a7 M - 构造与析构函数示例
$ R2 Q! F% j* b; ~' M - 析构函数执行!
复制代码this指针 每个对象都拥有一个this指针,this指针记录对象的内存地址。this指针是指向类自身数据的指针,简单来说就是指向当前类的当前实例对象。关于类的this指针有以下特点:
' Z6 `" T7 e) pthis只能在成员函数中使用,全局函数、静态函数都不能使用this this在成员函数的开始前构造,在成员函数的结束后清除 this指针会因编译器不同而有不同的放置位置。可能是栈,寄存器或者全局变量 0 b5 F8 ~/ j' C" h% ]' N
- /***** this_pointer_example.cpp *****/
1 C1 ]/ H2 c5 k) D1 \$ i - #include <iostream>
% K, ^) v* {( T4 s9 G - #include <string>
: G9 f2 F2 {- c$ I) S - using namespace std;
+ ]. a: E7 t9 L( _5 \ - 1 Y) e- ~( C) D* r
- class Dog {' _! w! q6 { b7 r& G! w& I
- public:
% T# x) e9 g/ I1 U( s$ P - string name;6 f5 s. z6 _( ]# b
- void func();
! f2 K5 j E; T1 P1 Z5 I, S6 r - };' _+ q! C" F6 }
- ' Z# X9 G+ g! D
- int main() {- ?6 K$ @) D b8 Y
- Dog dog;5 Z" G1 |9 y' Y
- dog.func();
3 |/ H" N/ F/ _ - return 0;
4 O( ^1 \8 i, X# ~1 \! G - }& z& ^- i3 Q/ [( K* A9 G. }
- //在类的成员函数里使用了this指针, 并指向了类里的成员name
* E/ Y) | D; @3 n. O% D - void Dog::func() {) u: w9 Z \$ Q3 k& |
- this->name = "旺财";9 j' E1 Q2 ], u
- cout<<"小狗的名字叫: "<<this->name<<endl;! z2 F) g6 H$ O% ~2 v: G
- }
复制代码执行下面的指令开始编译 - g++ this_pointer_example.cpp -o this_pointer_example
复制代码执行./this_pointer_example后结果如下 - 小狗的名字叫:旺财) F8 k& Y/ \- h' A/ _
复制代码 0 N$ j& q& G! o$ c" G" s
转载自嵌入式攻城狮
% |. A# O4 |) \
6 {6 |( l+ K i; K- l: Q2 W' Q |