C++-面向对象(一)

原创

wx5d0241bb88268 2022-03-06 11:30:48 博主文章分类：C++ ©著作权

文章标签 C++-面向对象(一) 初始化全局变量赋值 文章分类 代码人生

©著作权归作者所有：来自51CTO博客作者wx5d0241bb88268的原创作品，请联系作者获取转载授权，否则将追究法律责任

面向对象

类
对象
成员变量、成员函数
封装、继承、多态
…

类

C++中可以使用struct、class来定义一个类
struct和class的区别

struct的默认成员权限是public
class的默认成员权限是private

#include <iostream>
using namespace std;

struct Person {
  int m_id;
  int m_age;
  int m_height;

  void display() {
    cout << "m_id = " << this->m_id << endl;
    cout << "m_age = " << this->m_age << endl;
    cout << "m_height = " << this->m_height << endl;
  }
};

int main() {
  Person person;
  person.m_id = 10;
  person.m_age = 20;
  person.m_height = 30;

  Person *pPerson = (Person *)&person.m_age;
  pPerson->m_id = 40;
  pPerson->m_age = 50;

  person.display();

  getchar();
  return 0;
}

//struct Person {
//  int m_id;
//  int m_age;
//  int m_height;
//
//  void display() {
//    // this指向Person对象的指针
//    // this里面存储的就是Person对象的地址值
//    this->m_id = 5;
//    this->m_age = 6;
//    this->m_height = 7;
//
//    /*cout << "m_id = " << this->m_id << endl;
//    cout << "m_age = " << this->m_age << endl;
//    cout << "m_height = " << this->m_height << endl;*/
//  }
//};
//
//int main() {
//  Person person;
//  person.m_id = 1;
//  person.m_age = 2;
//  person.m_height = 3;
//  person.display();
//
//  Person person2;
//  person2.m_id = 4;
//  person2.m_age = 5;
//  person2.m_height = 6;
//  person2.display();
//
//  /*Person *pPerson = &person;
//  pPerson->m_id = 4;
//  pPerson->m_age = 5;
//  pPerson->m_height = 6;*/
//
//  /*
//  ebp-14h == &person
//
//   mov         dword ptr [ebp-14h],1  
//   mov         dword ptr [ebp-10h],2  
//   mov         dword ptr [ebp-0Ch],3 
//
//   ebp-20h == &pPerson
//
//   lea         eax,[ebp-14h]  
//   mov         dword ptr [ebp-20h],eax  
//
//   取出person对象的地址值，赋值给了eax
//   mov         eax,dword ptr [ebp-20h] 
//   mov         dword ptr [eax],4  
//
//   取出person对象的地址值，赋值给了eax
//   mov         eax,dword ptr [ebp-20h]  
//   mov         dword ptr [eax+4],5  
//
//   取出person对象的地址值，赋值给了eax
//   mov         eax,dword ptr [ebp-20h]  
//   mov         dword ptr [eax+8],6 
//  */
//
//  /*cout << "&person = " << &person << endl;
//  cout << "&person.m_id = " << &person.m_id << endl;
//  cout << "&person.m_age = " << &person.m_age << endl;
//  cout << "&person.m_height = " << &person.m_height << endl;
//
//  cout << sizeof(person) << endl;*/
//
//  getchar();
//  return 0;
//}

//struct Person {
//  int m_age;
//
//  void run() {
//    cout << "run() - age is " << m_age << endl;
//  }
//};
//
//int main() {
//  Person person;
//  person.m_age = 20;
//  person.run();
//
//  Person *pPerson = &person;
//  pPerson->m_age = 30;
//  pPerson->run();
//
//  // cout << sizeof(person) << endl;
//
//  getchar();
//  return 0;
//}

//struct Person {
private:
//  // 成员变量
//  int age;
//
//  // 成员函数
//  void run() {
//    cout << "run() - age is " << age << endl;
//  }
//
public:
  void test() {
    run();
  }
//};
//
//class Student {
//public:
//  int no;
//
//  void study() {
//    cout << "study() - no is " << no << endl;
//  }
//};
//
//int main() {
//  // 在栈空间分配了内存给person对象
//  // 这个person对象的内存会自动回收，不用开发人员去管理
//  Person person;
//  person.age = 20;
//  person.run();
//
//  Person person2;
//  person2.age = 30;
//  person2.run();
//
//  Student student;
//  student.no = 100;
//  student.study();
//
//  getchar();
//  return 0;
//}

编码规范

变量名规范参考

全局变量：g_
成员变量：m_
静态变量：s_
常量：c_
使用驼峰标识

this

this是指向当前对象的指针

封装

#include <iostream>
using namespace std;

//class Person {
//public:
//  int m_age;
//  void run() {
//    cout << "run()" << endl;
//  }
//};
//
//int main() {
//  Person person;
//  person.m_age = 10;
//  person.run();
//
//  return 0;
//}

struct Person {
private:
  int m_age;

public:
  void setAge(int age) {
    // 过滤
    if (age < 0) return;

    this->m_age = age;
  }

  int getAge() {
    return this->m_age;
  }
};


// 在C\C++中，定义在函数外面的就是全局变量
// 全局变量的特点：整个程序运行过程中都存在
int age;
Person p;

int main() {
  Person person;
  person.setAge(-20);

  cout << person.getAge() << endl;

  getchar();
  return 0;
}

内存布局

每个应用都有自己独立的内存空间，其内存空间一般都有以下几大区域
- 代码段（代码区）:用于存放代码
- 数据段（全局区）:用于存放全局变量等
- 栈空间
- - 每调用一个函数就会给它分配一段连续的栈空间，等函数调用完毕后会自动回收这段栈空间
  - 自动分配和回收
- 堆空间:需要主动去申请和释放

堆空间

在程序运行过程，为了能够自由控制内存的生命周期、大小，会经常使用堆空间的内存
堆空间的申请\释放

malloc \ free
new \ delete
new [] \ delete []

注意

申请堆空间成功后，会返回那一段内存空间的地址
申请和释放必须是1对1的关系，不然可能会存在内存泄露

现在的很多高级编程语言不需要开发人员去管理内存（比如Java），屏蔽了很多内存细节，利弊同时存在

利：提高开发效率，避免内存使用不当或泄露
弊：不利于开发人员了解本质，永远停留在API调用和表层语法糖，对性能优化无从下手

#include <iostream>
using namespace std;

void test() {
  // 申请4个字节的堆空间内存
  int *p = (int*)malloc(4);

  /*char *p = (char *)malloc(4);
  *p = 1;
  *(p + 1) = 2;

  p[0] = 1;
  p[1] = 2;*/
}

void test2() {
  int *p = new int;
  int *p2 = new int;

  delete p;
  delete p2;
}

void test3() {
  /*int *p = (int *)malloc(sizeof(int) * 10);
  p[0] = 10;
  p[1] = 10;
  p[2] = 10;
  p[3] = 10;

  free(p);*/

  int *p = new int[10];

  // delete [] p;
}

void test4() {
  int *p = new int; // 内存泄露 
  p = new int;

  delete p;
}

void test5() {
  int size = sizeof(int);
  int *p = (int *)malloc(size);
  // memory set
  // 从p开始的4个字节, 每个字节都存放0
  memset(p, 0, size);

  cout << *p << endl;

  free(p);
}

void test6() {
  // 没有初始化
  int *p1 = new int;
  // 初始化为0
  int *p2 = new int();
  // 初始化为5
  int *p3 = new int(5);
  // 没有初始化
  int *p4 = new int[3];
  // 全部元素初始化为0
  int *p5 = new int[3]();
  // 全部元素初始化为0
  int *p6 = new int[3]{};
  // 首元素初始化为5，其他元素初始化为0
  int *p7 = new int[3]{ 5 };

  cout << p7[0] << endl;
  cout << p7[1] << endl;
  cout << p7[2] << endl;
}

struct Person {
  int m_age;
};

// 全局区
Person g_person;

int main() {
  // 栈空间
  Person person;

  // 堆空间
  Person *p = new Person();
  p->m_age = 20;

  delete p;

  /*Person *p2 = (Person *) malloc(sizeof(Person));

  free(p2);*/

  getchar();
  return 0;
}