阅读 3390

Android NDK入门:C++ 基础知识

为什么写这篇文章

本文算作是 《Android 音视频开发打怪升级》系列文章的“番外”篇,原本打算将本文的内容写在 《Android FFmpeg视频解码播放》 这篇文章中,因为要想学习 FFmpeg 相关知识,C++ 的基础知识是必不可少的。

但是写着写着发现,篇幅还是太长了,加上有部分小伙伴对 C++ 可能也比较熟悉,所以把此节独立成篇,更有利于不熟悉 C++ 的小伙伴学习查看,熟悉的小伙伴也可以直接跳过。

C++ 相对于 Java 还是有许多的不同之处,对于没有使用过 C++ 的人来说,如果要学习 NDK 开发,C++ 是第一道坎,必须要掌握。

本文通过对比的方式,把 C++Java 之间最基础,也是最常使用知识的异同标记出来,方便大家学习。

当然了,本文只是重点对 C++ 中最常用的,也是重点的知识进行讲解,如有时间,最好还是系统地学一下相关的基础知识。

本文你可以了解到

本文使用对比的方式,将 C++ 与我们非常熟悉的 Java 进行对比学习,介绍 C++Java 使用的异同,帮助大家快速入门 C++

一、 C++ 基本数据类型

C++ 提供了一下几种基础数据类型

类型 关键字
布尔型 bool
字符型 char
整型 int
浮点型 float
双浮点型 double
无类型 void

同时,这些类型还可以被类型修饰符修饰,拓展出更多的数据类型:

类型修饰符 关键字
有符号类型 signed
无符号类型 unsigned
短类型 short
长类型 long

其中 signedunsigned 指定了数据是否有正负; shortlong 主要指定了数据的内存大小。

由于不同的系统,同个数据类型所占用的内存大小也不一定是一样的,以下是典型值:

类型 内存大小 范围
char 1 个字节 -128到127 或 0到255
unsigned char 1 个字节 0 到 255
signed char 1 个字节 -128 到 127
int 4 个字节 -2147483648 到 2147483647
unsigned int 4 个字节 0 到 4294967295
signed int 4 个字节 -2147483648 到 2147483647
short int 2 个字节 -32768 到 32767
unsigned short int 2 个字节 0 到 65,535
signed short int 2 个字节 -32768 到 32767
long int 8 个字节 -xxx 到 xxx
signed long int 8 个字节 -xxx 到 xxx
unsigned long int 8 个字节 -xxx 到 xxx
float 4 个字节 -xxx 到 xxx
double 8 个字节 -xxx 到 xxx
long double 16 个字节 -xxx 到 xxx

可以看到,

short 修饰符将原类型内存大小减小一半;

long 修饰符将原数据类型内存大小扩大一倍。

二、C++ 类

C++ 是一门面向对象的语言,类是必不可少的。其类的定义与 Java 大同小异。

Java 类通常声明和定义通常都是在同一个文件 xxx.java 中。

C++ 类的声明和定义通常是分开在两个不同的文件中,分别是 .h 头文件.cpp 文件

定义一个类

一个 类的头文件 通常如下:

// A.h

class A
{
private: //私有属性
    int a; 
    void f1();

protected: //子类可见
    int b;
    void f2(int i);

public: //公开属性
    int c = 2;
    int f3(int j);
    
    A(int a, int b); // 构造函数
    ~A(); //析构函数

};
复制代码

对应的类实现文件 A.cpp如下:

// A.cpp

/**
 * 实现构造函数
 */
A::A(int a, int b): 
a(a),
b(b) {
    
}

// 等价于

/*
A::A(int a, int b) {
    this.a = a;
    this.b = b;
}
*/

/**
 * 实现析构函数
 */
A::~A() {
    
}

/**
 * 实现 f1 方法
 */
void A::f1() {

    
}

/**
 * 实现 f2 方法
 */
void A::f2(int j) {
    this.b = j
}

/**
 * 实现 f3 方法
 */
int A::f3(int j) {
    this.c = j
}
复制代码

可以看到,.h 文件主要负责类成员变量和方法的声明; .cpp 文件主要负责成员变量和方法的定义。

但是,并非一定要按照这样的结构去实现类,你也可以在 .h 头文件中直接定义变量和方法。

比如:

// A.h

class A {
private:
    int a = 1;
    
public:
    void f1(int i) {
        this.a = i;
    }
}
复制代码

C++ 类中几个特别的地方

1) 可见性 private、protected、public

这几个关键字和 Java 是一样的,只不过在 C++ 中,通常不会对每个成员变量和方法进行可见性声明,而是将不同的可见性的变量和方法集中在一起,统一声明,具体见上面定义的类A。

2) 构造函数和析构函数

C++ 中类的构造函数和 Java 基本一致,只不过,在实现构造函数时,对成员变量的初始化方式比较特别。如下:

A::A(int a, int b): 
a(a),
b(b) {
    
}

// 等价于

A::A(int a, int b) {
    this.a = a;
    this.b = b;
}
复制代码

以上两种方式都可以,通常使用第一种方式。

析构函数 则是 Java 中没有的。通过波浪符号 ~ 进行标记。

它和构造函数一样,都是由系统自动调用,只不过,构造函数 在类创建的时候调用,析构函数 在类被删除的时候调用,主要用于释放内部变量和内存。

析构函数的声明形式为 ~类名();

实现的形式为 类名::~类名() { }

具体见上面类 A 的写法。

3) :: 双冒号

看了上面类的定义,肯定会对 :: 这个符号感到很神奇。这是 C++ 中的 域作用符,用于标示变量和方法是属于哪个域的,比如上面的

void A::a() { }
复制代码

说明 方法a 是属于 类A 的。

也可以用于调用类的静态成员变量,如

//A.h

class A {
private:
    static int a = 1;
    int b;
    void a();
}

//A.cpp
void A::a() {
    b = A::a;
}
复制代码

类的继承

C++ 类的继承和 Java 也是大同小异,其格式如下:

class B: access-specifier A,其中 access-specifier 是访问修饰符, 是 publicprotectedprivate 其中的一个。

访问修饰符的作用如下:

公有继承(public):当一个类派生自公有基类时,基类的公有成员也是派生类的公有成员,基类的保护成员也是派生类的保护成员,基类的私有成员不能直接被派生类访问,但是可以通过调用基类的公有和保护成员来访问。

保护继承(protected): 当一个类派生自保护基类时,基类的公有和保护成员将成为派生类的保护成员。

私有继承(private):当一个类派生自私有基类时,基类的公有和保护成员将成为派生类的私有成员。

通常情况下,我们都是使用 公有继承(public),也就是和 Java 是一样的。

类可以多继承

Java 中,子类只能继承一个父类,但是 C++ 可以继承自多个父类,使用逗号 , 隔开:

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};
复制代码

三、 C++ 指针

Java 中的 “指针”

Java 中,是没有指针的概念的,但是其实 Java 中除了基本数据类,大部分情况下使用都是 指针

比如下面这段 Java 代码:

People p1 = new People("David","0001");
People p2 = p1;
p2.setName("Denny");
System.out.println(p1.getName());

// 输出结果为:Denny
复制代码

原因就是 p1 和 p2 都是对对象的引用,在完成赋值语句 People p2 = p1; 后, p2 和 p1 指向同一个存储空间,所以对于p2的修改也影响到了p1。

那么,为什么在 Java 中很少去关注指针呢?

因为 Java 已经将指针封装了,也不允许显式地去操作指针,并且 Java 中的内存都由虚拟机进行管理,无需我们去释放申请的内存。

C++ 中的指针

1) 指针的声明和定义

Java 不同的是,C++ 中的指针概念非常重要,并且无处不在。

指针:是一个变量,这个变量的值是另一个变量的内存地址。也就是说,指针是一个指向内存地址的变量。

指针的声明和定义方法如下:

int a = 1; // 实际变量的声明

int *p; // 指针变量的声明

p = &a; // 指针指向 a 的内存地址

printf("p 指向的地址: %d, p指向的地址存储的内容: %d\n", p, *p);

// 输出如下:
// p 指向的地址: -1730170860, p指向的地址存储的内容: 1
复制代码

这个例子中有两个很重要的符号: *&。其中:

* :有两个作用:

i. 用于定义一个指针: type *var_name;var_name 是一个指针变量,如 int *p;

ii. 用于对一个指针取内容: *var_name, 如 *p 的值是 1

& :是一个取址符号

其用于获取一个变量所在的内存地址。如 &a; 的值是 a 所在内存的位置,即 a 的地址。

通过上面的例子,可能无法很好的理解指针的用处,来看另一个例子。

class A {
public:
    int i;
};

int main() {
    
    //-----1-------
    A a = A(); // 定变量 a
    a.i = 1;   // 修改 a 中的变量
    
    A b = a;   // 定义变量 b ,赋值为 a
    
    A *c = &a; // 定义指针 c,指向 a
    
    printf("%d, %d, %d\n", a.i, b.i, c->i);
    // 输出:1, 1, 1
    
    //-----2-------
    b.i = 2; //修改 b 中的变量
    
    printf("%d, %d, %d\n", a.i, b.i, c->i);
    // 输出:1, 2, 1
    
    //-----3-------
    c->i = 3; //修改 c 中的变量
    
    printf("%d, %d, %d\n", a.i, b.i, c->i);
    // 输出:3, 2, 3
    
    //-----4-------
    // 打印地址
    printf("%d, %d, %d\n", &a, &b, c);
    // 输出:-1861360224, -1861360208, -1861360224
    
    return 0;
}
复制代码

上面的例子,定义了一个变量 a ,然后将 a 分别赋值给普通变量 b 和指针变量 c

第一次,打印三个变量中的成员变量的 i 的值都为 1

第二次,修改了 b 中的 i,结果只修改了 b 的值,对 ac 都没有影响;

第三次,修改了 c 中的 i,结果修改了 ac 的值,对 b 都没有影响;

最后,打印了三个变量的地址,可以发现 ac 的值是一样的,b 的地址不一样。

从这个例子就可以看出端倪了:

通过 普通变量 赋值的时候,系统创建了一个新的独立的内存块,如 b,对 b 的修改,只影响其本身;

通过 指针变量 赋值时,系统没有创建新的内存块,而是将指针指向了已存在的内存块,如 c , 任何对 c 的修改,都将影响原来的变量,如 a

还有一点需要注意的是,指针变量 对成员变量的引用,使用的是箭头符号 ->,如 c->i ;普通变量对成员变量的引用,使用的是点符号 . ,如 b.i

2) new 和 delete

在上面的例子中,是通过创建了一个变量 a ,然后将 指针变量 c 指向了 a 的方式定义了 c。还有另外一种方法,可以声明和定义一个指针变量,那就是通过 new 动态创建

class A {
public:
    int i;
}

int main() {
    A *a = new A();
    a->i = 0;
    
    printf("%d\n", a->i);
    // 输出: 0
    
    // 删除指针变量,回收内存
    delete a;
    
    return 0;
}
复制代码

这就是动态创建指针变量的方式,这是 C++ 常用的方式。

重要提醒:

要注意的是,通过 new 的方式创建的指针变量和不通过 new 创建的变量最大的区别在于:通过 new 创建的指针需要我们自己手动回收内存,否则将会导致内存泄漏。回收内存则是通过 delete 关键字进行的。

也就是说,newdelete 必须要成对调用

int main() {
    A a = A(); // 无new,main 函数结束后,系统会自动回收内存
    
    A *b = new A(); // new 方式创建,系统不会自动回收内存,要手动 delete
    
    delete b; // 手动删除,回收内存
    
    return 0;
}
复制代码

可以看到,C++ 的指针变量其实更接近与 Java 中普通变量的使用方式。

四、C++ 引用

引用 是除了指针外,另一个非常重要的概念。在 C++ 也是经常使用的。

引用指的是:为一个变量起一个别名,也就是说,它是某个已存在变量的另一个名字。

引用和指针非常的相似,初学者非常容易把这两者混淆了。

引用的声明和定义

首先来看下如何声明一个引用变量。

// 声明一个普通变量 i
int i = 0;

// 声明定义一个引用 j
int &j = i;

j = 1;

printf("%d, %d\n", i, j)

// 输出:1, 1
复制代码

是不是有点熟悉,又是与符号 & ,但是这里并非表示取址,这里只是作为一个标示符号

请记住,千万不要和取址符号混淆,取址表示方式是:A *p = &a;

在上面的例子中,修改了 j 的值,i 的值也发生了变化。这和指针是不是非常像?

那么,引用和指针有什么不一样呢?

i. 不存在空引用。引用必须连接到一块合法的内存。

ii. 一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。

iii. 引用必须在创建时被初始化。指针可以在任何时间被初始化。

i 和 iii 都很好理解,就是声明引用的时候,必须要初始化好,并且不能初始化为空 NULL

ii 是最让人不理解的,什么叫做 “不能被指向到另一个对象” ?

引用和指针的区别

看以下的例子:

int i = 0;

// 定义引用 j ,指向 i
int &j = i;

int k = 1// 这个操作是指向另外一个对象吗?
j = k;

printf("%d, %d, %d\n", i, j, k);
// 输出:1, 1, 1

// 打印地址
printf("%d, %d, %d\n", &i, &j, &k);
// 输出:-977299952, -977299952, -977299948
复制代码

可以看到,i j k 三个的值都变成了 1,这看起来和指针是一样的效果,但却有质的区别。

看最后一个打印输出,ij 的地址始终是一样的,和 k 是不一样的。也就是说, j 始终指向 i ,不可改变。 j = k 只是把 k 的值给到了 j,同时也改变了 i

如果还不懂,再来看一下指针的例子,你就明白了。

int i = 0;

// 定义指针 j ,指向 i
int *j = &i;

int k = 1;

// 指向另一个对象
j = &k;

printf("%d, %d, %d\n", i, *j, k);
// 输出:0, 1, 1

// 打印地址
printf("%d, %d, %d\n", &i, j, &k);
// 输出:-1790365184, -1790365180, -1790365180
复制代码

看到了吗? j 在赋值了 &k 以后,地址就变成和 k 一样了,也就是说,指针 j 可以指向不同的对象。这时候, ji 就没有任何关系了,i 的值也不会随着 j 改变而改变。

如何使用引用

引用最常出现的地方是作为函数的参数使用。

void change(int &i, int &j) {
    int temp = i;
    i = j;
    j = temp;
}

int main() {
    int i = 0;
    int j = 1;
    
    // 打印地址
    printf("[before: %d, %d]\n", &i, &j);
    //输出:[before: -224237816, -224237812]
    
    change(i, j);
    
    printf("[i: %d, j: %d]\n", i, j);
    // 输出:i: 1, j: 0
    
    // 打印地址
    printf("[after: %d, %d]\n", &i, &j);
    // 输出:after: -224237816, -224237812
    
    return 0;
}
复制代码

在上面的例子中,change 方法的两个参数都是引用,和普通的参数有以下两个区别:

i. 引用参数不会创建新的内存块,参数只是对外部传进来的变量的一个引用。

ii. 引用参数可以改变外部变量的值。

这是普通变量的情况:

void change(int i, int j) {
    int temp = i;
    i = j;
    j = temp;
    
    // 打印地址
    pritf("[change: %d, %d]\n", &i, &j);
    // 输出[change: -1136723044, -1136723048]
}

int main() {
    int i = 0;
    int j = 1;
    
    // 打印地址
    printf("[before: %d, %d]\n", &i, &j);
    //输出:[before: -224237816, -224237812]
    
    change(i, j);
    
    printf("[i: %d, j: %d]\n", i, j);
    // 输出:i: 0, j: 1
    
    // 打印地址
    printf("[after: %d, %d]\n", &i, &j);
    // 输出:after: -224237816, -224237812
    
    return 0;
}
复制代码

可以看到,i j 的值不会被改不变,原因是 change 方法创建了两个临时的局部变量,都有自己的内存块,这个变量的地址和外部传进来的变量是没有关系的,所以无法改变外部变量的值。

到这里,就可以看到参数引用的好处了:引用参数为我们节省了内存,执行效率也更快。

同样的,指针参数也有类似的效果,但是其仍然和引用有着本质的区别。引用为我们提供另一个种很好的传参选择。

有时候,我们并不想让函数内部改变外部变量的值,可以给参数加上常量的标志。

void change(const int &i, const int &j) {
    int temp = i;
    i = j;     // 不允许修改i,编译出错
    j = temp;  // 不允许修改j,编译出错
}
复制代码

五、C++ 多态和虚函数

多态 是面向对象的三大特点之一。

C++ 的多态和 Java 非常相似,但是也有着明显的不同。

静态绑定

看下面一个例子:

class A {
public:
    void f() {
        printf("a\n");
    };
};

class B : public A {
public: 
    void f() {
        printf("b\n");
    };
};

int main() {
    A *a = new B();
    a->f();
    // 输出:a
    
    return 0;
}
复制代码

这里 B 继承了 A,并重写了方法 f

main 函数中,定义了一个基类变量指针 a ,并指向子类 B 。接着调用了 a 的方法 f

如果是 Java 中类似的操作的话,那么毫无疑问,此处会输出 b,可是这里却输出了 a 。也就是说,这里方法 f 实际上是基类 Af 方法。

这就是 C++Java 其中一个很大的不同。

原因是,调用函数 f() 被编译器设置为基类中的版本,这就是所谓的静态多态,或静态链接

函数调用在程序执行前就准备好了。有时候这也被称为早绑定,因为 f() 函数在程序编译期间就已经设置好了。

那么如果想实现类似 Java 中的多态重载呢?

虚函数

virtualC++ 中的一个关键字,用于声明函数,表示虚函数。用于告诉编译器不要静态链接到该函数,改为动态链接

依然是上面的例子,在 Af 函数上加上 virtual,将得到类似 Java 的效果:

class A {
public:
    virtual void f() {
        printf("a\n");
    };
};

class B : public A {
public: 
    void f() {
        printf("b\n");
    };
};

int main() {
    A *a = new B();
    a->f();
    // 输出:b
    
    return 0;
}
复制代码

纯虚函数

Java 中,我们经常会使用 interfaceabstract 来定义一些接口,方便代码规范和拓展,但是在 C++ 没有这样的方法,但是可以有类似的实现,那就是:纯虚函数

class A {
public:
    // 声明一个纯虚函数
    virtual void f() = 0;
}

class B : public A {
public: 
    // 子类必须实现 f ,否则编译不通过
    void f() {
        printf("b\n");
    };
};

int main() {
    A *a = new B();
    a->f();
    // 输出:b
    
    return 0;
}
复制代码

A 中的 virtual void f() = 0; 就是一个纯虚函数。如果继承 A,子类必须实现 f 这个接口,否则编译不通过。

A 则是一个抽象类。不能被直接定义使用。

六、C++ 预处理

C++ 中有一个方法,可以让我们在程序编译前,对代码做一些处理,称为预处理。这是 Java 中没有的,在 C++ 中却经常使用到。

预处理是一些指令,但是这些指令并不是 C++ 语句,所以不需要以分号 ; 结束。

所有的预处理语句都是以井号 # 开始的。

比如 #include 就是一个预处理,用于将其他文件导入到一个另一个文件中,类似 Javaimport

例如导入头文件:

// A.h
class A{
public:
    A();
    ~A();
}
复制代码
#include "A.h"

A::A() {
    
}

A::~A() {
    
}
复制代码

C++ 中常用的预处理有以下几个 #include#define#if#else#ifdef#endif 等。

宏定义

最常用的一个预处理语句 #define ,通常称为宏定义

其形式为:

#define name replacement-text 
复制代码
#define PI 3.14159

printf("PI = %f", PI);

// 在编译之前,上面的语句被展开为:
// printf("PI = %f", 3.14159);

复制代码
  • 带参数宏定义
#define SUM(a,b) (a + b)

printf("a + b = %d", SUM(1, 2));

// 在编译之前,上面的语句被展开为:
// printf("a + b = %d", 1 + 2);
// 输出:a + b = 3
复制代码
  • ### 运算符

在宏定义中,# 用于将参数 字符串化

#define MKSTR( x ) #x

printf(MKSTR(Hello C++));

// 在编译之前,上面的语句被展开为:
// printf("Hello C++");
// 输出: Hello C++
复制代码

在宏定义中,## 用于将参数 连接起来

#define CONCAT(a, b) a ## b

int xy = 100;

printf("xy = %d", CONCAT(x, y));

// 在编译之前,上面的语句被展开为:
// printf("xy = %d", xy);
// 输出:xy = 100
复制代码

注意:### 在多个宏定义嵌套使用的时候,会导致不展开的问题

例如:

#define CONCAT(x, y) x ## y

#define A a

#define B b

void mian() {

    char *ab = "ab";
    char *AB = "AB";
    
    printf("AB = %s", CONCAT(A, B));
    
    // 在编译之前,上面的语句被展开为:
    // printf("AB = %s", AB);
}
复制代码

虽然定义了 A B 两个宏定义,但是在 CONCAT 中遇到 ## 的时候,A B 这两个宏定义是不会开展的,而是直接当作两个参数被连接起来了。

那么要如何解决这个问题呢?那就是再转接一层。

#define _CONCAT(x, y) x ## y
#define CONCAT(x, y) _CONCAT(x, y)

#define A a

#define B b

void mian() {

    char *ab = "ab";
    char *AB = "AB";
    
    printf("AB = %s", CONCAT(A, B));
    
    // 在编译之前,上面的语句被展开为:
    // printf("AB = %s", _CONCAT(a, b));
    // printf("AB = %s", ab);
    // 输出:AB = ab
}
复制代码

条件编译

#if#else#ifdef#endif 这几个的组合主要用条件编译。

C++ 中条件编译也是经常使用到的,可以用来控制哪些代码参与编译,哪些不参与编译。

#define DEBUG

int main() {

#ifdef DEBUG
    // 参与编译
    printf("I am DEBUG\n");
#else
    // 不参与编译
    printf("No DEBUG\n");
#endif

    return 0;
}

// 输出:I am DEBUG
复制代码

以上代码,由于先前已经定义了 #define DEBUG 所以 #ifdef DEBUGtrue ,编译 printf("I am DEBUG\n");

如果去掉 #define DEBUG ,则编译 printf("No DEBUG\n");

int main() {

#if 0
    // 这里面的代码都被注释掉,不参与编译
    printf("I am not compiled\n");
#endif

    return 0;
}
复制代码

七、总结

以上,基本就是在 C++ 经常使用到的,与 Java 相似,又存在差异的一些基础知识,由于面向对象语言都存在一定的相似性,相信有了以上的基础之后,你就可以比较通畅地阅读一些 C++ 代码了。

如果你是一个 Java 程序员,可能对其中的一些知识还是会感到迷惑,这时候需要你抛弃 Java 中的一些惯有思维,重新细细品尝一下 C++ 的味道,可以实际的去敲一下代码来消化这些知识,只有实践才能出真知。

推荐两个网站:

C++ 菜鸟教程

C++ 在线编译