C/C++基础(6)

类

类的基本定义

#include <iostream>

using namespace std;

class Animal {

private:
    char name[64];
    int type;
public:
    char* getName() {
        return name;
    }
    void setName(char* name) {
        strcpy(this->name, name);
    }
    void setType(int type) {
        this->type = type;
    }
    int getType() {
        return type;
    }
};


int main(int argc, const char * argv[]) {
    Animal dog;
    //strcpy(dog.getName(), "gougougou");
    dog.setName("gougou");
    dog.setType(1);
    cout << dog.getName() << " type: " << dog.getType() << endl;
    return 0;
}

拷贝构造函数

class Test {
  public:
    Test(int a, int b) {
        this->a = a;
        this->b = b;
        cout << "构造函数" << endl;
    }
    //默认的拷贝构造函数是浅拷贝
    //显示的拷贝构造函数，可用来完成深拷贝
    Test(const Test &another) {
      this->a = another.a;
      this->b = another.b;
    }
  private:
  int a;
  int b;
}

void test() {
    Test t1(1, 2);
    Test t2(t1);  //调用Test的拷贝构造函数

    //注意，如下操作不会调用拷贝构造函数，而是会调用=操作符函数
    Test t3(3,3);
    t1 = t3;
}

构造函数和析构函数

class Test {
  public:
    Test(int a, int b) {
        this->a = a;
        this->b = b;
        cout << "构造函数" << endl;
    }
    ~Test() {
      cout << "析构函数" << endl;
    }
  private:
  int a;
  int b;
}

析构函数最常用于内存对象的回收，回收专门在对象内部分配的额外空间。比如对象内部有char *name的属性，给name malloc了堆内存，析构用于回收name的堆空间。

构造函数的初始化列表

#include <stdio.h>
#include <iostream>

using namespace std;

class A {
private:
    int a;
public:
    A(int a) {
        this->a = a;
        cout << "A的int a构造方法" << endl;
    }
};

class B {
public:
    //构造对象成员的顺序跟初始化列表的顺序无关
    //跟成员对象的定义顺序有关
    //用a1和a2对B类中的a1和a2进行赋值
    B(A &a1, A &a2, int b) : a1(a1), a2(a2){
        this->b = b;
    }
private:
    int b;
    A a1;
    A a2;
};

int main(void) {
    //用a1，a2在b的构造函数中进行赋值
    A a1(10);
    A a2(20);
    B b(a1, a2, 100);
    
}

new和delete创建对象和回收内存

//malloc free是函数，标准库， stdlib.h
//new 在堆上初始化一个对象的时候，会触发对象的构造函数。malloc不会触发。
//delete会触发析构函数，free不会
void cpp() {
    int *p = new int;
    *p = 10;
    if(p!=NULL) {
        delete p;
    }
    
    //数组
    int *array_p = new int[10];
    for(int i=0;i<10;i++) {
        array_p[i] = i;
    }
    if(array_p != NULL) {
        delete [] array_p;
    }

    //A *a1 = new A(10);
    //A *a2 = new A(20);
    //B *b = new B(*a1, *a2, 100);
}

void c() {
    int *p = (int *)malloc(sizeof(int));
    *p = 10;
    if(p!=NULL) {
        free(p);
        p = NULL;
    }
    
    //数组
    int *array_p = (int *)malloc(sizeof(int) * 10);
    for(int i=0;i<10;i++) {
        array_p[i] = i;
    }
    if(array_p != NULL) {
        free(array_p);
        array_p = NULL;
    }
}

static成员变量

class StaticA {
private:
    int a;
public:
    //static修饰静态成员变量
    static int b;
    static void addStatic() {
        b++;
    }
};

//在类的外边进行初始化，全局共享
int StaticA::b = 10;
StaticA::addStatic();

1. static成员变量实现了同类对象间的全局共享
2. static成员类外存储，类大小不包括static的变量
3. static成员是命名空间属于类的全局变量，存储在data区
4. static成员只能类外部初始化
5. 可以通过类名访问，也可以通过对象访问。

this指针

this->内部属性
this就是指向调用当前成员函数的对象地址

// 类 Test
int getA() {
  this->a = 10;  //这里可以修改this指向的属性，this指针不是const Test * this
  //this++   // this指针是一个常指针，Test * const this
  return a;
}

//如果不允许在方法内部通过this修改属性值，在函数外部增加const
int getB() const {
  //this->a = 10;  //这里的this指针不允许被修改，当前状态为const Test * const this
  //this++   // this指针是一个常指针，Test * const this
  return a;
}

返回对象自身

Test& get() {
    return *this;
}

友元函数

通过指定外部函数为友元函数，来允许外部函数访问类的私有变量。
友元单向，且不具备继承性

class Test() {
  private:
    int a;
  public:
    int getA() {
      return a;
    } 
  //声明全局函数 a是Test类的一个友元函数。
  friend void a();
  //如果是其他类的函数，则增加类名::
  friend void A::a();
  //如果是其他类，可以声明友元类
  friend class A;
}
void a() {
  Test test;
  test.a = 1; //定义友元函数可以直接在类外部使用私有变量
}

操作赋重载

这里对+号进行操作重载，使+号可以直接两个自定义类型的相加

Test operator+(Test &t1, Test &t2) {
  // ...
}
int main(void) {
  Test t1;
  Test t2;
  Test t3 = t1+t2; //opreator+(t1,t2);  或t1.operator+(t2);
}