C++ | 对象的初始化和清理

//1、构造函数分类
// 按照参数分类分为 有参和无参构造   无参又称为默认构造函数
// 按照类型分类分为 普通构造和拷贝构造

class Person {
public:
  //无参（默认）构造函数
  Person() {
    cout << "无参构造函数!" << endl;
  }
  //有参构造函数
  Person(int a) {
    age = a;
    cout << "有参构造函数!" << endl;
  }
  //拷贝构造函数
  Person(const Person& p) {
    age = p.age;
    cout << "拷贝构造函数!" << endl;
  }
  //析构函数
  ~Person() {
    cout << "析构函数!" << endl;
  }
public:
  int age;
};

//2、构造函数的调用
//调用无参构造函数
void test01() {
  Person p; //调用无参构造函数
}

//调用有参的构造函数
void test02() {

  //2.1  括号法，常用
  Person p1(10);
  //注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明
  //Person p2();

  //2.2 显式法
  Person p2 = Person(10); 
  Person p3 = Person(p2);
  //Person(10)单独写就是匿名对象  当前行结束之后，马上析构

  //2.3 隐式转换法
  Person p4 = 10; // Person p4 = Person(10); 
  Person p5 = p4; // Person p5 = Person(p4);

  //注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明
  //Person p5(p4);
}

int main() {

  test01();
  //test02();

  system("pause");

  return 0;
}

class Person {
public:
  Person() {
    cout << "无参构造函数!" << endl;
    mAge = 0;
  }
  Person(int age) {
    cout << "有参构造函数!" << endl;
    mAge = age;
  }
  Person(const Person& p) {
    cout << "拷贝构造函数!" << endl;
    mAge = p.mAge;
  }
  //析构函数在释放内存之前调用
  ~Person() {
    cout << "析构函数!" << endl;
  }
public:
  int mAge;
};

//1. 使用一个已经创建完毕的对象来初始化一个新对象
void test01() {

  Person man(100); //p对象已经创建完毕
  Person newman(man); //调用拷贝构造函数
  Person newman2 = man; //拷贝构造

  //Person newman3;
  //newman3 = man; //不是调用拷贝构造函数，赋值操作
}

//2. 值传递的方式给函数参数传值
//相当于Person p1 = p;
void doWork(Person p1) {}
void test02() {
  Person p; //无参构造函数
  doWork(p);
}

//3. 以值方式返回局部对象
Person doWork2()
{
  Person p1;
  cout << (int *)&p1 << endl;
  return p1;
}

void test03()
{
  Person p = doWork2();
  cout << (int *)&p << endl;
}


int main() {

  //test01();
  //test02();
  test03();

  system("pause");

  return 0;
}

class Person {
public:
  //无参（默认）构造函数
  Person() {
    cout << "无参构造函数!" << endl;
  }
  //有参构造函数
  Person(int age ,int height) {
    
    cout << "有参构造函数!" << endl;

    m_age = age;
    m_height = new int(height);
    
  }
  //拷贝构造函数  
  Person(const Person& p) {
    cout << "拷贝构造函数!" << endl;
    //如果不利用深拷贝在堆区创建新内存，会导致浅拷贝带来的重复释放堆区问题
    m_age = p.m_age;
    m_height = new int(*p.m_height);
    
  }

  //析构函数
  ~Person() {
    cout << "析构函数!" << endl;
    if (m_height != NULL)
    {
      delete m_height;
    }
  }
public:
  int m_age;
  int* m_height;
};

void test01()
{
  Person p1(18, 180);

  Person p2(p1);

  cout << "p1的年龄：" << p1.m_age << " 身高：" << *p1.m_height << endl;

  cout << "p2的年龄：" << p2.m_age << " 身高：" << *p2.m_height << endl;
}

int main() {

  test01();

  system("pause");

  return 0;
}

class Person {
public:

  ////传统方式初始化
  //Person(int a, int b, int c) {
  //  m_A = a;
  //  m_B = b;
  //  m_C = c;
  //}

  //初始化列表方式初始化
  Person(int a, int b, int c) :m_A(a), m_B(b), m_C(c) {}
private:
  int m_A;
  int m_B;
  int m_C;
};

class A {}
class B
{
    A a；
}

class Person
{
  
public:

  static int m_A; //静态成员变量

  //静态成员变量特点：
  //1 在编译阶段分配内存
  //2 类内声明，类外初始化
  //3 所有对象共享同一份数据

private:
  static int m_B; //静态成员变量也是有访问权限的
};
int Person::m_A = 10;
int Person::m_B = 10;

void test01()
{
  //静态成员变量两种访问方式

  //1、通过对象
  Person p1;
  p1.m_A = 100;
  cout << "p1.m_A = " << p1.m_A << endl;

  Person p2;
  p2.m_A = 200;
  cout << "p1.m_A = " << p1.m_A << endl; //共享同一份数据
  cout << "p2.m_A = " << p2.m_A << endl;

  //2、通过类名
  cout << "m_A = " << Person::m_A << endl;


  //cout << "m_B = " << Person::m_B << endl; //私有权限访问不到
}

int main() {

  test01();

  system("pause");

  return 0;
}