封装
- 成员变量私有化，提供公共的set，get方法给外界去访问成员变量；
#include <iostream>
using namespace::std;
struct Person {
private:
int m_age;
public:
void setAge(int age){
this->m_age = age;
}
int getAge(){
return this->m_age;
}
};
int main(int argc, const char * argv[]) {
Person person;
person.setAge(20);
int age = person.getAge();
cout << "person age = " << age << endl;
return 0;
}
-
this是指针，通过指针访问结构体的成员，必须用箭头
内存布局
- 每个应用都有自己的独立的内存空间，其内存空间一般都有以下几个区域：
- 代码区：用于存放代码；
- 数据全局区：用于存放全局变量；
- 栈区：没调用一个函数就会给函数分配一段连续的栈空间，等函数调用完毕后，系统会自动回收这段栈空间；
- 堆空间：需要主动区申请和释放；
堆空间
- 在程序运行过程中，为了能自由控制内存的生命周期，大小，会经常使用堆空间的内存；
- 堆空间的申请与释放：
- malloc / free
- new / delete
- new [ ] / delete [ ]
- 注意点：
- 申请堆空间成功后，会返回那一段堆空间的内存地址；
- 申请与释放必须是一对一的关系，否则会出现内存泄漏；
#include <iostream>
using namespace::std;
void test1() {
//申请4个字节的堆空间内存
int *p = (int *)malloc(4);
*p = 10;
//释放堆空间内存
free(p);
}
void test2() {
//申请4个字节的堆空间内存
int *p = new int;
*p = 20;
//释放堆空间内存
delete p;
}
void test3(){
//申请4*10个字节的堆空间内存
int *p1 = (int *)malloc(sizeof(int) * 10);
p1[0] = 10;
p1[1] = 10;
p1[2] = 10;
p1[3] = 10;
//释放
free(p1);
//申请4*10个字节的堆空间内存
int *p2 = new int[10];
//释放
delete [] p2;
}
int main(int argc, const char * argv[]) {
test1();
test2();
test3();
return 0;
}
堆空间的初始化
#include <iostream>
using namespace::std;
void test4() {
int size = sizeof(int);
//申请4个字节的堆空间内存
int *p = (int *)malloc(size);
//从p开始的4个字节都存放0
memset(p, 0, size);
cout << *p << endl;
}
void test5(){
//未初始化
int *p1 = new int;
//初始化为0
int *p2 = new int();
//初始化为5
int *p3 = new int(5);
//数组元素未被初始化
int *p4 = new int[3];
//3个数组元素都被初始化为0
int *p5 = new int[3]();
//3个数组元素都被初始化为0
int *p6 = new int[3]{};
//数组首元素被初始化为5，其他元素被初始化为0
int *p7 = new int[3]{5};
}
int main(int argc, const char * argv[]) {
test4();
test5();
return 0;
}
-
memset函数，主要用来给堆空间内存初始化，赋值的；且可以实现将较大的数据结构(结构体，数组)的内存快速清零；
对象的内存
- C++中对象的内存可以存在于三种内存区域；
- 栈区：函数里面的局部变量；
- 全局区：全局变量；
- 堆区：动态申请堆内存(malloc / new)
#include <iostream>
using namespace::std;
struct Person {
private:
int m_age;
public:
void setAge(int age){
this->m_age = age;
}
int getAge(){
return this->m_age;
}
};
//全局区内存
Person g_p1;
int main(int argc, const char * argv[]) {
//栈区内存
Person person;
//堆区内存
Person *p = new Person();
return 0;
}
构造函数
- 构造函数也叫做构造器，在对象创建的时候自动调用，一般用于完成对象的初始化操作；
- 其特点有如下：
- 函数名于类名相同，无返回值，可以有参数，可以重载，可以有多个构造函数；
- 一旦自定义构造函数，必须用其中一个构造函数来初始化对象；
- 通过malloc分配的对象不会调用构造函数；
- 在某些特定情况下，编译器会为类生成空的无参的构造函数；
#include <iostream>
using namespace::std;
struct Person {
int m_age;
//构造函数的重载
Person() {
cout << "Person()" << endl;
}
Person(int age) {
this->m_age = age;
cout << "Person(int age)" << endl;
}
};
int main(int argc, const char * argv[]) {
//会调用构造函数Person()
Person person;
person.m_age = 20;
//会调用构造函数Person(int age)
Person person1 = Person(30);
//会调用构造函数Person()
Person *p1 = new Person();
//会调用构造函数Person(int age)
Person *p2 = new Person(33);
//不会调用构造函数
Person *p3 = (Person *)malloc(sizeof(Person));
return 0;
}
构造函数的调用
#include <iostream>
using namespace::std;
struct Person {
int m_age;
//构造函数的重载
Person() {
//所有成员变量，全部清零
memset(this, 0, sizeof(Person));
cout << "Person()" << endl;
}
Person(int age) {
this->m_age = age;
cout << "Person(int age)" << endl;
}
};
//全局区
Person g_person1;
//这是个函数声明，不是调用Person的构造函数
Person g_person2();
Person g_person3(30);
int main(int argc, const char * argv[]) {
//栈区
Person person1;
//这是个函数声明，不是调用Person的构造函数
Person person2();
Person person3(31);
//堆区
Person *p1 = new Person;
Person *p2 = new Person();
Person *p3 = new Person(32);
return 0;
}
- 全局区，调用两次构造函数；
- 栈区，调用两次构造函数；
- 堆区，调用三次构造函数；
析构函数
- 析构函数也叫析构器，在对象销毁的时候自动调用，一般用于完成对象的清理工作；
- 析构函数的特点：
- 函数名以
~开头，与类同名，无返回值，无参数，不可以重载，有且只有一个析构函数；
- 通过
malloc分配的对象的在free的时候是不会调用析构函数的；
- 构造函数与析构函数都要被声明为
public，这样才能被外界正常使用；
#include <iostream>
using namespace::std;
struct Person {
int m_age;
//构造函数
Person() {
cout << "Person()" << endl;
}
//析构函数 回收Person对象内部申请的堆空间car
~Person() {
cout << "~Person()" << endl;
}
};
int main(int argc, const char * argv[]) {
//栈区person对象
Person person;
//堆区person对象
Person *p = new Person();
delete p;
return 0;
}
对象的内存管理
#include <iostream>
using namespace::std;
struct Car {
int m_price;
Car() {
cout << "Car()" << endl;
}
~Car() {
cout << "~Car()" << endl;
}
};
struct Person {
int m_age;
Car *car;
//构造函数
Person() {
cout << "Person()" << endl;
car = new Car();
}
//析构函数 回收Person对象内部申请的堆空间car
~Person() {
cout << "~Person()" << endl;
delete this->car;
}
};
int main(int argc, const char * argv[]) {
//堆区person对象
Person *p = new Person();
delete p;
return 0;
}
- 堆区person对象在销毁之前，必须要销毁清理内部堆区对象car，否则会产生内存泄漏；
声明与实现的分离
- 类的声明放在
.hpp头文件，类的实现放在.cpp实现文件
// Person.hpp
// C++11_声明与实现的分离
//
// Created by ljj on 8/12/21.
//
#ifndef Person_hpp
#define Person_hpp
#include <stdio.h>
//声明
class Person {
int m_age;
public:
Person();
~Person();
void setAge(int age);
int getAge();
};
#endif /* Person_hpp */
// Person.cpp
// C++11_声明与实现的分离
//
// Created by ljj on 8/12/21.
//
#include "Person.hpp"
#include <iostream>
using namespace::std;
//实现
// :: 域运算符
Person::Person(){
cout << "Person()" << endl;
}
Person::~Person(){
cout << "~Person()" << endl;
}
void Person::setAge(int age){
this->m_age = age;
}
int Person::getAge(){
return this->m_age;
}
- 最后在
main文件中导入#include "Person.hpp"
// main.cpp
// C++11_声明与实现的分离
//
// Created by ljj on 8/12/21.
//
#include <iostream>
#include "Person.hpp"
using namespace::std;
int main(int argc, const char * argv[]) {
{
Person person;
person.setAge(30);
cout << person.getAge() << endl;
}
return 0;
}
