NDK | C++ 复习笔记

声明命名空间：
namespace xurui {
    int age = 1;
    char * name = "xurui";
}
使用命名空间（要求放在声明之后，可以在文件头调用，也可以在函数内调用）：
using namespace xurui;
访问命名空间内的成员：
xurui::name 或 name（没用冲突时，可以省略命名空间::）
复制代码

#include<iostream> // C++ 标准库
using namespace std; // 命名空间，类似于 Java 的内部类
cout<< "C++" << endl; // 引用引用了std::命名空间，所以可以省略
复制代码

cout << true << endl;
输出：1
复制代码

C：假常量
const int number = 100;
int * numP = &number;
*numP = 10000;
printf("%d\n", number); // 10000，“常量了” 被修改
C++：真常量
const int number = 100;
// 有的编译器不通过，有的可以通过但运行报错
int * numP = &number;
复制代码

int add(int n1 = 0, int n2 = 1) {
}
复制代码

#include <stdarg.h>
using namespace std;
void sum(int count, ...) {
    va_list vp;
    va_start(vp, count);
    for (int index = 0; index < count; index++) {
        int number = va_arg(vp, int);
        cout << number << endl;
    }
    va_end(vp);
}
int main() {
    // 输出：
    // 1
    // 2
    // 3
    sum(3, 1, 2, 3);
    return 0;
}
复制代码

int add(int n1){
    return n1;
}
int add(int n1 = 1,int n2 = 1){
    return n1 + n2;
}
int main(){
    add(1); （X）// Call to 'add' is ambiguous
}
复制代码

Student .h：
class Student {
public:
    Student operator+(Student student);
};
Student .cpp：
Student Student::operator+(Student student) {
    return Student();
}
----------------------------------------------
更严格的写法：
class Student {
public:
    Student operator+(const Student &student);
};
注意：如果没有使用 &，函数调用时会额外构建一个对象副本（拷贝构造函数）
Student Student::operator+(const Student &student) {
    return Student();
}
复制代码

class Student {
// 私有成员
private:
    char*name;
    int age;
};
复制代码

class Student {
public:
    char *getName() const;
    void setName(char *name);
    int getAge() const;
    void setAge(int age);
// 私有成员
private:
    char*name;
    int age;
};
复制代码

char *Student::getName() const {
    return name;
}
void Student::setName(char *name) {
    Student::name = name; // 或 this->name = name;
}
int Student::getAge() const {
    return age;
}
void Student::setAge(int age) {
    Student::age = age; // 或 this->age = age;
}
复制代码

静态开辟：栈
Student student; // 未调用构造函数
student.setAge(10);
student.setName("mark");
cout << "name:" << student.getAge() << ",name:" << student.getName() << endl;
Student student2("Amy") // 会调用构造函数
// 函数出栈是会隐式调用 delete
动态开辟：堆
Student *student = new Student(); // 会调用构造函数
student->setAge(10);
student->setName("mark");
cout << "name:" << student->getAge() << ",name:" << student->getName() << endl;
if (student) {
    delete student; // new 分配的空间用 delete
    student = NULL; // 防止存现悬空指针
    // free(student); // (X) malloc 分配的空间用 free
}
复制代码

声明
class Student {
public:
    Student();
    Student(char*name);
    ~Student();
};
----------------------------------------------
// 调用另一个重载构造函数
Student::Student() : Student("mark") {
}
Student::Student(char *name) {
    this->name = (char *) (malloc(sizeof(char) * 10));
    strcpy(this->name, name);
}
Student::~Student() {
    // 必须释放构造器中开辟的堆区成员
    if (this->name) {
        free(this->name);
        this->name = NULL;
    }
}
复制代码

情况 1：指针赋值，没有调用拷贝构造函数
Student* student1 = new Student();
Student* student2 = student1;
情况 2：隐式调用拷贝构造函数
Student student1;
Student student2 = student1; 
情况 3：不会调用自定义的拷贝构造函数，但会调用默认拷贝构造函数
Student student1;
Student student2; 
student2 = student1; 
复制代码

class Student {
public:
    1、先声明静态成员：
    static int id;
    static void update(){
        id = 2;
    }
};
复制代码

2、再实现静态成员（必须）：
int Student::id = 1;
复制代码

Student student;
cout << student.id << endl;
Student::update();
cout << student.id << endl;
输出：
1
2
复制代码

class Student {
public:
    friend void setAge(Student * student,int age);
private:
    int age;
};
复制代码

void setAge(Student *student, int age) {
    student->age = age;
}
int main() {
    Student student;
    setAge(&student, 1);
    // 输出：
    // 1
    cout<<student.getAge()<<endl;
    return 0;
}
复制代码

class ImageView {
private:
    int viewSize;
    friend class Class; // 友元类
};
class Class {
public:
    ImageView imageView;
    void changeViewSize(int size) {
        imageView.viewSize = size; // 如果不声明友元类 “friend class Class”，无法访问
    }
};
复制代码

class Rectangle: public Shape, public PaintCost
{
   public:
      int getArea()
      { 
         return (width * height); 
      }
};
复制代码

// 间接基类A
class A{
protected:
    int m_a;
};
// 直接基类B
class B: virtual public A{  // 虚继承
protected:
    int m_b;
};
// 直接基类C
class C: virtual public A{  // 虚继承
protected:
    int m_c;
};
复制代码

virtual void funtion1()=0;
复制代码

template <class T> void swap(T& a, T& b){
}
复制代码

template<class T> class A{
public: 
T a; 
T b; 
T hy(T c, T &d);
};
复制代码