NDK开发（三） - C++基础

C是面向过程的语言，而C++是面向对象的。如果是Java开发者会更习惯与使用C++，从Android系统源码能看出，Native层开发主要采用的也是C++，C语言更多的还是作为Kernel层的开发语言。因此也有必要针对C++来做一个梳理，从语言上，C++完全兼容C，很多东西都是相通的，因此与C相同的内容就不再赘述。

一、命名空间

C++引入命名空间(namespace)，主要是避免命名冲突的问题。
namespace有系统定义的，也可以自定义。
举例：
C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。
使用C++打印：
1）使用命名空间去点对应标识符：

std::cout << "Hello, World!" << std::endl;

2）使用命名空间对应标识符：

using std::cout;
using std::endl;
cout << "Hello, World!" << endl;

3）直接使用命名空间：

using namespace std;
cout << "Hello, World!" << endl;

二、引用与指针

C++在C指针的基础上，增加引用的支持。
引用是别名，指针是地址。二者区别：

• 指针可以被重新赋值以指向另一个不同的对象。而引用则总是指向在初始化时被指定的对象，以后不能改变，但是指定的对象其内存可以改变。
• 程序为指针变量分配内存区域，可以指向空值。而不为引用分配内存区域，不可指向空值。

举例：

//指针传递
void swap(int *a, int *b) {
    int tmp;
    tmp = *a;
    *a = *b;
    *b = tmp;
}

//引用传递
void swap1(int &a, int &b) {
    int tmp;
    tmp = a;
    a = b;
    b = tmp;
}

int main() {
   int a = 1;
    int b = 2;
    swap(&a, &b);
    swap1(a, b);
    return 0;
}

二、字符串

C++引入string

#include 
int main() {
    string str = "hello";
    cout << str << endl;
    return 0;
}

三、面向对象

这部分是C++区别于C的核心内容。

3.1 类与对象

class Shape {
/**
 * 访问修饰符
 * public
 * private 只有类和友元函数可以访问私有成员
 * protect 类、友元函数、子类可以访问受保护成员
 */
public:
    //无参构造方法(直接实现)
    Shape() {
   
    };

    //带参构造方法声明(外部实现)
    Shape(double len);

    //析构函数
    ~Shape() {
     //在每次删除所创建的对象时执行, 主要做些释放资源的事
    }

    //静态成员
    static int objectCount;

    //成员变量
    int width;
    int height;

    //成员函数声明(外部实现)
    int getArea1();

    //成员函数直接实现
    int getArea2() {
        return 0;
    }

    /**
     * 友元函数：类的友元函数是实现在类外部的，但具有访问类private和protected的成员变量与函数
     * 注意：
     *    友元函数不能使用this
     *    友元函数不能被子类继承
     * @param shape
     */
    friend void printLength(Shape shape);

protected:
    int length;
private:
    void show() {
        cout << "show" << endl;
    }
};

//成员函数定义
int Shape::getArea1() {
    return 0;
}

//带参构造方法
Shape::Shape(double width) {
    this->width = width;
    cout << "constructor create:length " << width << endl;
}

//友元函数实现
void printLength(Shape shape) {
    cout << "length:" << shape.length << endl;
    shape.show();
}

//初始化静态变量
int Shape::objectCount = 1;

int main() {
    //无参构造函数
    Shape shape;
    //有参构造函数三种调用方法:
    Shape shape1(1.23);
    Shape shape2 = (1.23);
    Shape shape3 = Shape(1.23);
    cout << "objectCount:" << Shape::objectCount << endl;

    printLength(shape);
    return 0;
}
浅拷贝：拷贝指针变量的值。
深拷贝：拷贝指针所指向的内存空间。

3.2 抽象类与继承

class Shape {
public:
   //纯虚函数, =0 告诉编译器，函数没有主体
    virtual int getArea() = 0;

protected:
    int width = 1;
    int height = 2;
};

//派生子类
//多继承：class <派生类名>:<访问控制1><基类名1>,<访问控制2><基类名2>,…
class Rectangle : public Shape {
public:
    int getArea() {
        return width * height;
    }
};

int main() {
    Rectangle rect;
    cout << rect.getArea() << endl;
}

类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。
抽象类不能被用于实例化对象，它只能作为接口使用。

3.3 重载

函数重载

class printData
{
   public:
     //print重载
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
 
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
 
};

运算符重载

class Shape {

public:
    int width = 1;

    Shape() {}

    Shape(int w) {
        width = w;
    }
    
    //重载 + 运算符，用于把两个Shape对象相加
    Shape operator+(const Shape &shape) {
        Shape s;
        s.width = width + shape.width;
        return s;
    }
};

int main() {
    Shape shape;
    Shape shape1 = Shape(2);
    const Shape &s = shape.operator+(shape1);
    cout << s.width << endl;
}

支持重载的运算符：

双目算术运算符: + ，-，，/，%
关系运算符: ==，!=， < ，> ，<=，>=
逻辑运算符: ||，&&，!
单目运算符: + ，-，，&
自增自减运算符: ++，--
位运算符: | ，& ，~，^，<< ，>>
赋值运算符: =, +=, -=, *=, /= , % = , &=, |=, ^=, <<=, >>=
空间申请与释放: new, delete, new[ ] , delete[]
其他运算符: ()(函数调用)，->(成员访问)，,(逗号)，

3.4 多态

配合虚函数实现多态

class Shape {
public:
    //虚函数
    virtual int area() {
        cout << "Parent class area :" << endl;
        return 0;
    }
};

class Rectangle : public Shape {
public:
    int area() {
        cout << "Rectangle class area" << endl;
    }
};

class Triangle : public Shape {
public:

    int area() {
        cout << "Triangle class area" << endl;
    }
};

int main() {
    //父类指针指向不同子类对象地址，这是C++多态一般使用方式
    Shape *shape;
    Rectangle rectangle;
    Triangle triangle;

    shape = &rectangle;
    shape->area();

    shape = ▵
    shape->area();
}

四、动态内存分配

C++中使用new和delete来动态分配和释放内存。malloc() 函数在 C 语言中就出现了，在 C++ 中仍然存在，new 与 malloc() 函数相比，其主要的优点是：new 不仅分配了内存，它还创建了对象。
//为对象动态分配内存

Shape *pShape = new Shape();

//为对象释放内存
delete pShape;

五、信号处理

#include 

static void signalHandler(int signum) {
    cout << "abort signal (" << signum << ") received.\n";
    exit(signum);
}

int main() {
    // 注册信号 SIGINT 和信号处理程序,因为它并不属于POSIX(Portable Operating System Interface)标准,即:可移植操作系统接口
    // 在各类 UNIX 平台上的实现不尽相同，因此其用途受到了一定的限制。
    signal(SIGABRT, signalHandler);
    /**
     * sigaction 结构体
     *
     * sa_handler: 设置处理函数handler
     * sig.sa_sigaction: 也是设置处理函数handler，但是与sa_handler对应的handler传参不一样
     * sa_mask: 用来设置在处理该信号时暂时将sa_mask指定的信号集搁置
     * sa_flags:
     *   SA_ONSTACK      0x0001  take signal on signal stack
     *   SA_RESTART      0x0002  restart system on signal return
     *   SA_RESETHAND    0x0004   reset to SIG_DFL when taking signal
     *   SA_NOCLDSTOP    0x0008  do not generate SIGCHLD on child stop
     *   SA_NODEFER      0x0010  don't mask the signal we're delivering
     *   SA_NOCLDWAIT    0x0020  don't keep zombies around
     *   SA_SIGINFO      0x0040  signal handler with SA_SIGINFO args
     */
    struct sigaction sig;
    sig.sa_flags = SA_RESETHAND;
    sig.sa_handler = signalHandler;
    /**
     *  int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact);
     *
     *  signum: 要操作的信号
     *  act: 新的对信号的处理方式
     *  oldact: 原来对信号的处理方式
     *  return: 0表示成功,-1表示有错误发生
     */
    sigaction(SIGABRT, &sig, NULL);
    abort();
}

六、模板

类似java泛型

6.1 函数模板

template
void swap_(T &a, T &b){
    T temp = a;
    a = b;
    b = temp;
}
int main(){
    //交换 int 变量的值
    int n1 = 100, n2 = 200;
    swap_(n1, n2);
    cout<

6.2 类模板

template  //这里不能有分号
class Point
{
public:
    Point(T1 x, T2 y): m_x(x), m_y(y){ }
public:
    T1 getX() const;  //获取x坐标
    void setX(T1 x);  //设置x坐标
    T2 getY() const;  //获取y坐标
    void setY(T2 y);  //设置y坐标
private:
    T1 m_x;  //x坐标
    T2 m_y;  //y坐标
};

typename也可以用class

七、类型转换

转换类型操作符	作用
const_cast	去掉类型的const或volatile属性。
static_cast	无条件转换，静态类型转换。
dynamic_cast	有条件转换，动态类型转换，运行时检查类型安全（转换失败返回NULL）。
reinterpret_cast	仅重新解释类型，但没有进行二进制的转换。

使用举例：

class Person {
public:
    Person() {}
    ~Person() {}

    int age;

    virtual void character() {};
};

class Student : public Person {
public:
    int classId;
};

void func() {}

typedef void(*FuncPtr)();//函数指针

int main() {
    //const_cast
    const Person p;
    //p.age = 10;//不能直接修改const类型
    Person per = const_cast(p);
    per.age = 10;
    cout << "age:" << per.age << endl;

    //static_cast
    int n = 6;
    double d = static_cast(n); //基本类型转换

    //dynamic_cast
    Person *person = new Student();
    Student *stu = dynamic_cast(person);//子类->父类，动态类型转换

    //reinterpret_cast
    FuncPtr funcPtr = reinterpret_cast(&func);//不同函数指针类型之间进行转换
}

总结：

• 去const属性用const_cast
• 基本类型转换用static_cast
• 多态类之间的类型转换用dynamic_cast
• 不同类型的指针类型转换用reinterpret_cast

未完待续...