2017C++基础——网课笔记（40到45）

最新推荐文章于 2019-03-25 14:17:51 发布
最新推荐文章于 2019-03-25 14:17:51 发布
阅读量234 收藏
点赞数
分类专栏： C++ 学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/garrulousabyss/article/details/79796415
版权

四十. 构造函数的初始化列表1 
#include <iostream>

using namespace std;

class A
{
public:
    A(int a)
    {
        cout<<"A()..."<<endl;
        m_a = a;
    }

    ~A()
    {
        cout<<"~A()..."<<endl;
    }

    void printA()
    {
        cout<<"a = "<<m_a<<endl;
    }
private:
    int m_a;
};

class B
{
public:
    B(A& a1, A& a2, int b): m_a1(a1),m_a2(a2)
    {
        m_b = b;
    }

    void printB()
    {
        cout<<"b= "<< m_b <<endl;
        m_a1.printA();
        m_a2.printA();
    }

    ~B()
    {
        cout<<"~B()..."<<endl;
    }

private:
    int m_b;
    A m_a1;
    A m_a2;
};
int main()
{
    A a1(10),a2(100);

    B b(a1,a2,1000);
    b.printB();
    return 0;
}

四十一. 构造函数的初始化列表2（略）

四十二.强化练习1 
#include <iostream>
#include <stdio.h>
using namespace std;

class ABCD
{
public:
    ABCD(int a, int b, int c)
    {
        _a = a;
        _b = b;
        _c = c;
        printf("ABCD() construct, a:%d, b:%d, c:%d \n",_a,_b,_c);
    }

    ~ABCD()
    {
        printf("ABCD() destruct, a:%d, b:%d, c:%d \n",_a,_b,_c);
    }

    int getA()
    {
        return _a;
    }
private:
    int _a;
    int _b;
    int _c;
};

class MyE
{
public:
    MyE(): abcd1(1,2,3), abcd2(4,5,6),m(100)
    {
        cout<<"MyD().."<<endl;
    }

    ~MyE()
    {
        cout<<"~MyE()..."<<endl;
    }

    MyE(const MyE& obj):abcd1(7,8,9), abcd2(10,11,12),m(100)
    {
        cout<<"MyE(const MyE& obj)"<<endl;
    }

public:
    ABCD abcd1;
    ABCD abcd2;
    const int m;
};

int doThing(MyE mye1)
{
    cout<<"doThing() mye1.abc1.a:"<<mye1.abcd1.getA()<<endl;
    return 0;
}

int run()
{
    MyE myE;
    doThing(myE);
    return 0;
}

int run2()
{
    cout<<"run2() starts...."<<endl;
    ABCD(400,500,600);
    cout<<"run2() ends...."<<endl;
    return 0;
}

int main()
{
    run2();
    return 0;
}


四十三.强化练习2 
#include <iostream>

using namespace std;

class MyTest
{
public:
    MyTest(int a, int b, int c)
    {
        _a = a;
        _b = b;
        _c = c;
    }

    MyTest(int a, int b)
    {
        _a = a;
        _b = b;
        MyTest(a,b,100); //产生新的匿名对象
    }

    ~MyTest()
    {
        cout<<"~Mytest:"<<_a<<", "<<_b<<", "<<_c<<endl;
    }

    int getC()
    {
        return _c;
    }

    void setC(int val)
    {
        _c = val;
    }
private:
    int _a;
    int _b;
    int _c;


};
int main()
{
    MyTest t1(20,30);
    return 0;
}

四十四.new和delete1 
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;

//c语言中
void test1()
{
    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 +1;
    }

    for(int i = 0;i<10;i++)
    {
        printf("%d",array_p[i]);
    }

}

//c++中
void test2()
{
    int * p = new int;
    *p = 10;
    if(p != NULL)
    {
        delete p;
        p = NULL;
    }

    int *array_p = new int[10];

    for(int i = 0; i<10; i++)
    {
        array_p[i] = i +1;
    }

    for(int i = 0;i<10;i++)
    {
        cout<< array_p[i]<<" ";
    }

    cout<<endl;

    if(array_p != NULL)
    {
        delete [] array_p;
    }
}

int main()
{
    test1();

    cout<<endl<<"---------------------------"<<endl;

    test2();

    return 0;
}

四十五.new和delete2

这里，我们必须对《new与malloc》，《delete与free》这两组关系有比较清晰的认识


delete tp释放的是tp本身，而析构函数，是用来析构new出来的空间。

delete也是类似，delete会做的事，事先去触发析构函数，再去销毁对象。而与此同时，free本身，只是去销毁对象，释放空间。它缺了delete的第一步。

2. 基于上述原因，我们需要掌握delete与delete[]之间的区别
（1）基本数据类型分配和回收空间

针对内置类型(即基本数据类型)使用new分配后的不管是数组还是非数组形式内存空间用两种方式均可，如：

int *a = new int[10];
delete a;//正确
<=>等价于
delete[] a;//正确

代码示例：


#include <iostream>;

using namespace std;
int main()
{
    int NUM = 3;

    int *a1 = new int[NUM];
    cout<<a1<<endl;
    delete a1;
    cout<<"释放了a1的空间"<<endl;

    int *a2 = new int[NUM];
    cout<<a2<<endl;
    delete[] a2;
    cout<<"释放了a2的空间"<<endl;

    system("pause");
    return 0;
}
=>01294750
  释放了a1的空间
  01294750
  释放了a2的空间
注：此种情况中的释放效果相同，原因在于：分配简单类型内存时，内存大小已经确定，系统可以记忆并且进行管理，在析构时，系统并不会调用析构函数。
它直接通过指针可以获取实际分配的内存空间，哪怕是一个数组内存空间(在分配过程中系统会记录分配内存的大小等信息，此信息保存在结构体_CrtMemBlockHeader中，具体情况可参看VC安装目录下CRT\SRC\DBGDEL.cpp)
（2）自定义类型分配和回收空间(即对象数组的内存管理)

  • 针对自定义类型使用new分配后的空间，若是数组形式的内存空间，两种方式效果截然不同，如：

    T *a = new T[10];
delete a;//错误，仅释放了a指针指向的全部内存空间 但是只调用了a[0]对象的析构函数，剩下的从a[1]到a[9]这9个用户自行分配的对应内存空间将不能释放 从而造成内存泄漏。
<!=>效果截然不同
delete[] a;//正确，调用使用类对象的析构函数释放用户自己分配内存空间并且释放了a指针指向的全部内存空间

  • 错误程序示例：

    
#include <iostream>;

using namespace std;
class T 
{
public:
    T() 
    {
        cout <<"构造T"<<endl;
    }
    ~T() 
    {
        cout <<"析构T"<<endl;
    }
};
int main()
{
    int NUM = 3;

    T *p1 = new T[NUM];
    cout<<p1<<endl;
    delete p1;//错误释放语句
    cout<<"释放了p1空间"<<endl;

    T *p2 = new T[NUM];
    cout<<p2<<endl;
    delete[] p2;//正确释放语句
    cout<<"释放了p2空间"<<endl;

    system("pause");
    return 0;
}
=>构造T
  构造T
  构造T
  010F4754
  析构T
  程序崩溃了Debug Assertion Failed!
  Expression：_BLOCK_TYPE_IS_VALID(pHead->nBlockUse)
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40

  • 正确程序示例：

    
#include <iostream>;

using namespace std;
class T 
{
public:
    T() 
    {
        cout <<"构造T"<<endl;
    }
    ~T() 
    {
        cout <<"析构T"<<endl;
    }
};
int main()
{
    int NUM = 3;

    T *p1 = new T[NUM];
    cout<<p1<<endl;
    delete[] p1;//正确释放语句
    cout<<"释放了p1空间"<<endl;

    T *p2 = new T[NUM];
    cout<<p2<<endl;
    delete[] p2;//正确释放语句
    cout<<"释放了p2空间"<<endl;

    system("pause");
    return 0;
}
=>构造T
  构造T
  构造T
  1664754
  析构T
  析构T
  析构T
  释放了p1空间
  构造T
  构造T
  构造T
  1664754
  析构T
  析构T
  析构T
  释放了p2空间
    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49

    注：在用这些类生成对象数组的时候，用delete[]来释放它们才是王道。

（3）总结，别管那么多，反正如果定义的事单个个体，就delete。
如果定义的是数组，就delete[]，这样绝对不会出错
garrulousabyss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++多线程网课学习(13-07)
Nancy_fairy的博客
01-29 1478
1.设计模式概述 【概念】代码的一些写法：程序灵活，维护方便；但代码晦涩，不易于别人接手。 2. 单例设计模式 【概念】：整个项目中，有某个或某些特殊的类，属于该类的对象，只能被创建1个。 3. 单例设计模式共享数据分析及解决 3.1 建议 建议在多线程中，将单例类在主线程中提前定义并初始化相关静态变量。 如果对单例类中变量只读，则只读的共享数据不需要加锁。 如果：需要在子线程中创建单例类对象，这种线程且不止一个，则会出现撞上初始化被多次执行。解决方法：增加互斥量 //.cpp //类的私
2017C++基础——网课笔记（15到18）
fighting2019的博客
03-25 133
常引用： const引用让变量拥有只读属性 ； 3 const引用结论 1）Const & int e 相当于 const int * const e 2）普通引用 相当于 int *const e1 3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名 4）使用字面量对const引用初始化后，将生成一个只读变量...
2017C++基础——网课笔记【下】（15到22）
garrulousabyss的博客
07-12 264
十五. 作业（略）十六. 昨日回顾（略）十七. 多态案例——几何图形#include &lt;iostream&gt; using namespace std; //----------抽象层---------------------- class Shape { public: //打印出图形的基本属性 virtual void show() = 0; //得到图形...
《C++语言基础》网络课程主页
热门推荐
迂者-贺利坚的专栏
03-07 1万+
返回 贺利坚教学链接 　　本课程是在大学的实体课程基础上建设的一门网络课程，将我在教学中建设的资源，让更多的人能够用到。 　　课程链接是：点击打开链接 　　同步实体课在　点击打开链接，那里有92名同时学习的“同学”，以及他们的博客链接。 　　坚持这门课程学习的学员，请在评论处留言，我将建立专门的链接，一起建设学习的氛围。 　　学员链接：（待加） 课程内容 一、从C到C++...
2017C++基础——网课笔记（5到9）
fighting2019的博客
03-24 217
转：https://www.cnblogs.com/chenhuan001/p/5836766.html https://blog.csdn.net/garrulousabyss/article/details/79775111 五.三目运算符的加强 C++中，三目运算符可以作为左值使用，而在C中，三目运算符只可当作右值，不可当作左值 #include <iostre...
2017C++基础——网课笔记（19到22）
fighting2019的博客
03-25 101
十九. 函数重载 5 函数重载（Overroad） 函数重载概念 1 函数重载概念 函数重载(Function Overload) 用同一个函数名定义不同的函数 当函数名和不同的参数搭配时函数的含义不同 2 函数重载的判断标准 /* 函数重载至少满足下面的一个条件： ...
2017C++基础——网课笔记（32到35）
garrulousabyss的博客
04-02 270
三十二. 构造和析构（略）三十三. 默认的无参构造函数和析构函数构造函数可以重载析构函数不能重载这两者，如果不写，则是默认的，无参的构造函数，无参的析构函数。但是只要去显式的写了，则系统不会有自动的构造函数哦or析构函数了三十四. 拷贝构造函数1. 拷贝构造函数，会将值一五一十的赋给新的类2. 对于以下两种情况，其实调用的都是t3的拷贝构造函数，这两种写法是等价的//这里当然调用的是t3的拷贝构造...
C++基础学习笔记————网课
08-18
个人网课学习笔记
详解C++基础——类继承
12-31
好吧，本系列博客已经变成了《C++ Primer Plus》的读书笔记，尴尬。在使用C语言时，多通过添加库函数的方式实现代码重用，但有一个弊端就是原来写好的代码并不完全适用于现在的情况。OOP设计思想中类的继承相比来说...
零基础学C/C++03——Very Good!
最新发布
08-26
零基础学C/C++03——Very Good! #include using namespace std; int main() { cout***************"!"***************"; return 0; }
一个好玩的c++游戏——生死枪战！
07-27
生死枪战游戏目前以3个模式运行（持续更新），玩家可以通过自己的喜好来选择，如：新手训练营，无限...如果想要更多c++游戏，请进入zzz工作室，网址http://zzz07.ysepan.com/ 我的聊天室网址：https://hack.chat/?zzz
c++提高编程--网课笔记
08-26
网课笔记
GeekBand-极客班-C++算法原理与实践-董飞-课程笔记（一）
X@IAS
07-20 2952
GeekBand-极客班-C++算法原理与实践-董飞-课程笔记（一）算法入门和编程风格
2017C++基础——网课笔记（54到58）
garrulousabyss的博客
04-08 609
五十四.对象返回自身五十五. 强化练习，自定义的数组类这个例子呢，一共分为3个文件，分别是：main.cpp#include &lt;iostream&gt; #include "MyArray.h" using namespace std; int main() { MyArray array1(10); for(int i=0; i&lt;10;i++){ ...
C++ Primer学习笔记：从基础到实践
“C++primer全书笔记，详尽记录了C++的基础知识，包括源代码风格、变量命名约定、输入输出、操作符重载、函数原型、数据处理等方面，适合C++初学者。” C++编程语言是面向对象的，具有丰富的特性，适用于系统编程、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值