美文网首页
C++入门04 --封装，内存布局，内存分配，构造/析构函数

C++入门04 --封装，内存布局，内存分配，构造/析构函数

作者: YanZi_33 | 来源:发表于2021-08-11 18:40 被阅读0次

封装

  • 成员变量私有化，提供公共的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;
}

相关文章

  • C++入门04 --封装，内存布局，内存分配，构造/析构函数

    封装 成员变量私有化，提供公共的set，get方法给外界去访问成员变量； this是指针，通过指针访问结构体的成员...

  • C/C++基础(6)

    类 类的基本定义 拷贝构造函数 构造函数和析构函数 析构函数最常用于内存对象的回收，回收专门在对象内部分配的额外空...

  • windows逆向3

    VC 程序内存和编译的一些特征C++ 构造函数C++ 成员函数C++ 析构函数C++ 全局对象的构造C++ 全局对...

  • 动态内存和类

    析构函数 如果类对象成员指向一块new分配的内存，则需要编写一个析构函数来释放内存。当删除类对象时，C++会释放对...

  • C++基础-构造函数和拷贝函数

    构造函数 析构函数 析构函数： 相当于临终遗言，对象被回收的时候会被调用。如果有在对象内部开辟堆内存，在析构函数里...

  • 构造函数和析构函数

    鸡啄米：C++编程入门系列之十四（类与对象：构造函数和析构函数）

  • 简介python中的析构函数与构造函数

    python的构造和析构函数为固定的名字。 构造函数 析构函数 不像c++中那样构造函数和析构函数是类名字。并且在...

  • 2.3、内存管理

    用户层：STL —— 自动分配、释放内存资源——调c++c++ —— new/delete，构造/析构 —— 调...

  • [GeekBand] C++面向对象程序设计-2

    一个类的对象的生命历程如下： 申请内存——>初始化列表——>构造函数——>参与运算——>析构函数——>释放内存。 ...

  • 第十五章 析构过程

    c++中，如果没有定义析构函数，c++会提供一个默认析构函数；由于swift采用自动引用计数来进行内存管理，不需要...

网友评论

      本文标题：C++入门04 --封装，内存布局，内存分配，构造/析构函数

      本文链接：https://www.haomeiwen.com/subject/zwhcbltx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|C++入门04 --封装，内存布局，内存分配，构造/析构函数|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！