C++---Day07

最新推荐文章于 2024-05-17 11:10:00 发布
最新推荐文章于 2024-05-17 11:10:00 发布
阅读量787 收藏
点赞数
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_48983250/article/details/123532300
版权
保证线程安全的方法：

线程安全，互斥量加信号锁，原子操作

无锁队列（锁锁住的时候不进行用户态和内核态的切换）

智能指针不能保证线程安全

什么时候专门对析构函数释放所创建对象的空间：

析构函数不能释放对象创建的空间，析构函数释放所占的资源（构造的时候生成的堆资源，在构造的时候定义了一个文件指针，指向了文件流对象，等到释放的时候，关闭文件流对象）

如何释放对象所占的空间：

先明确对象创建在哪个位置点

主函数结束，主函数的空间要回收

析构函数是释放对象所占的资源

空间是由系统进行回收的

class Object
{
    FILE* fp;
 public:
    Object(char* filename)
    {
        fp = fopen(filename,"w");
    }
    ~Object()
    {
        fclose(fp);
        fp = NULL;
    }
};
Object obja;//.data，先于主函数创建，等到整个程序结束的时候，调用析构函数，空间由系统管理
int main()
{
    Object objb;//.stack，函数调用，给它分配空间，调动构造函数创建对象，空间由于主函数的消失而回收
    Object *p = new Object();//.heap
    delete p;//1.调动析构函数；2.把堆空间还给系统
    return 0;
}
C++切片问题：只存在于公有继承

继承关系，公有继承 是一个

把子对象给父对象时，才会有切片问题

因为子对象里有隐藏父对象

class Object
{
    int value;
 public:
    Object(int x = 0):value(x){}
    
};
class Base:public Object
{
    int num;
 public:
    Base(int x = 0):Object(x+10),num)x
    {}
};
对象在内存中的表达
#include"stdio.h"
#include<stdlib.h>
#include<assert.h>
#define SEQ_INIT_SIZE 10
class SeqList
{
    int data[SEQ_INIT_SIZE];
    int maxsize;
    int cursize;
 public:
    SeqList():maxsize(SEQ_INIT_SIZE),cursize(0)
    {
        
    }
    ~SeqList()
    {
        
    }
};
int main()
{
    SeqList seqa;
}

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2
class SeqList
{
 private:
    int *data;
    int maxsize;
    int cursize;
    SeqList(const SeqList& seq) = delete;
    //C 11 ,防止进行拷贝构造
    SeqList& operator=(const SeqList& seq) = delete;
 public:
    SeqList():maxsize(SEQ_INIT_SIZE),cursize(0)
    {
        data = (int*)malloc(sizeof(int)*maxsize);
    }
    ~SeqList()
    {
        free(data);
        data = NULL;
    }
    //缺省赋值语句
    //为什么此处不能用列表方式进行:因为对象只能构建一次以及对象里面的数据成员只能构建一次
    //SeqList& operator=(const SeqList& seq)
   // {
        //if(this != &seq)
        //{
            //maxsize = seq.maxsize;
            //cursize = seq.cursize;
            //memcpy(data,seq.data,sizeof(data));
        //}
        //return *this;
    //}
    
    //缺省拷贝构造函数
    //SeqList(const SeqList& seq):maxsize(seq.maxsize),cursize(seq.cursize)//加const使程序的通用性更好
    //{
        //memcpy(data,seq.data, sizeof(data));
       // memcpy(data,seq.data, sizeof(int)*cursize);
    //}
};
SeqList fun(SeqList seq)
{
    SeqList seqx;
    return seqx;
}
int main()
{
    SeqList seqa;
    SeqList seqb(seqa);
    SeqList seqc;
    seqc = seqb;
    fun(seqa);
}
构造函数设置为私有时，如何创建全局对象？

静态函数的使用方式

是否可以把析构函数设计为私有？不可以，对象无法死亡

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2
class SeqList
{
 private:
    int *data;
    int maxsize;
    int cursize;
 public:
    SeqList():data(NULL),maxsize(SEQ_INIT_SIZE),cursize(0)
    {
        data = (int*)malloc(sizeof(int)*maxsize);
    }
    SeqList(const SeqList& seq)
    {
        data = seq.data;
        maxsize = seq.maxsize;
        cursize = seq.cursize;
    }
    SeqList& operator = (const SeqList& seq)
    {
        if(this != &seq)
        {
            data = seq.data;
            maxsize = seq.maxsize;
            cursize = seq.cursize;
        }
        return *this;
    }
    ~SeqList()
    {
        free(data);
        data = NULL;
    }
};
int main()
{
    SeqList seqa;
    SeqList seqb(seqa);
    return 0;
}
//空间释放两次，导致程序崩溃

class Vector
{
    int* _first;
    int* _last;
    int* _end;
 public:
    Vector():_first(NULL),_last(NULL),_end(NULL)
    {
        _first = (int*)malloc(sizeof(int)*SEQ_INC_SIZE);
        _last = _first;
        _end = _first +SEQ_INIT_SIZE;
    }
    Vector(const Vector& vec):
    
    ~Vector()
    {
        free(first);
        _first = _last = _end;
    }
};
int main()
{
    Vector vec; 
}
vec._last - vec._first = 元素的个数;cursize
vec._end - vec._first = 容量的大小;maxsize

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2
class SeqList
{
 private:
    int *data;
    int maxsize;
    int cursize;
 public:
    SeqList():data(NULL),maxsize(SEQ_INIT_SIZE),cursize(0)
    {
        data = (int*)malloc(sizeof(int)*maxsize);
    }
    SeqList(const SeqList& seq)
    {
        data = seq.data;
        maxsize = seq.maxsize;
        cursize = seq.cursize;
    }
    SeqList& operator = (const SeqList& seq)
    {
        if(this != &seq)
        {
            data = seq.data;
            maxsize = seq.maxsize;
            cursize = seq.cursize;
        }
        return *this;
    }
    ~SeqList()
    {
        free(data);
        data = NULL;
    }
};
int main()
{
    SeqList seqa;
    SeqList seqb;
    seqb = seqa;
    return 0;
}//会发生内存泄漏
什么时候要写自己的拷贝构造函数和重载赋值语句

在类设计的过程中，设计出指针或者设计出指向内核态对象，文件具名指针，线程，信号量，互斥量，写自己的拷贝构造函数和重载赋值语句

指针通过new或者malloc使用堆区空间

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2
class SeqList
{
 private:
    int *data;
    int maxsize;
    int cursize;
 public:
    SeqList():data(NULL),maxsize(SEQ_INIT_SIZE),cursize(0)
    {
        data = (int*)malloc(sizeof(int)*maxsize);
    }
    SeqList(const SeqList& seq)
    {
        maxsize = seq.maxsize;
        cursize = seq.cursize;
        data = (int*)malloc(sizeof(int)*seq.maxsize);
        memcpy(data,seq.data,sizeof(int)*seq.cursize);//由浅拷贝变成深拷贝
    }
    SeqList& operator = (const SeqList& seq)
    {
        if(this != &seq)
        {
            data = seq.data;
            maxsize = seq.maxsize;
            cursize = seq.cursize;
        }
        return *this;
    }
    ~SeqList()
    {
        free(data);
        data = NULL;
    }
};
int main()
{
    SeqList seqa;
    SeqList seqb;
    seqb = seqa;
    return 0;
}

#define SEQ_INIT_SIZE 10
#define SEQ_INC_SIZE 2
class SeqList
{
 private:
    int *data;
    int maxsize;
    int cursize;
 public:
    SeqList():data(NULL),maxsize(SEQ_INIT_SIZE),cursize(0)
    {
        data = (int*)malloc(sizeof(int)*maxsize);
    }
    SeqList(const SeqList& seq)
    {
        maxsize = seq.maxsize;
        cursize = seq.cursize;
        data = (int*)malloc(sizeof(int)*seq.maxsize);
        memcpy(data,seq.data,sizeof(int)*seq.cursize);//由浅拷贝变成深拷贝
    }
    SeqList& operator=(const SeqList& seq)
    {
        if(this != &seq)
        {
            //释放原有空间
            free(data);
            data = (int*)malloc(sizeof(int)*seq.maxsize);
            memcpy(data,seq.data, sizeof(int)*cursize);
            memcpy(data,seq.data, sizeof(int)*cursize);
            maxsize = seq.maxsize;
            cursize = seq.cursize;
        }
        
        return *this;
    }
    ~SeqList()
    {
        free(data);
        data = NULL;
    }
};
int main()
{
    SeqList seqa;
    SeqList seqb;
    seqb = seqa;
    return 0;
}

对于内置类型，malloc和delete可以混用，new和free可以混用

对于自定义类型，是不允许的

class String
{
    char* str;
 public:
    String(const char* p = NULL):str(NULL)
    {
        if(p != NULL)
        {
            str = new char[strlen(p) + 1];
            strcpy(str,p);
        }
        else
        {
            str = new char[1];
            *str = '\0';
        }
    }
    ~String()
    {
        if(str != NULL)
        {
            delete[] str;
        }
        str = NULL;
    }
    //重载插入操作符 
    //ostream& operator<<(const String* const this,ostream& out)
    ostream& operator<<(ostream& out)const
    {
        if(str != NULL)
        {
            out<<str;
        }
        return out;
    }
    String(const String& s)
    {
        str = s.str;
    }
    //浅拷贝，或者系统提供的拷贝构造函数
    
    //如何把浅拷贝变为深拷贝
    
    //s1<<cout;
    //s1.operator<<(cout);
    //operator<<(&s1,cout);
};
//const只能修饰this指针
ostream& operator<<(ostream& out,const String& s)
{
    s << out;
    //s.operator<<(&s,out);
    //operator<<(&s,out);
    return out;
}
int main()
{
    String s1("yhpinghello");
    cout<<s1<<endl;
    operator<<(cout,s1);
}


int main()
{
    String s1("yhpinghello");
    s1<<cout;
}

int main()
{
    String s1("yhpinghello");
    cout<<s1<<endl;
    cout<<12<<endl;
    cout<<"yhping"<<endl;
}

class String
{
    char* str;
 public:
    String(const char* p = NULL):str(NULL)
    {
        if(p != NULL)
        {
            str = new char[strlen(p) + 1];
            strcpy(str,p);
        }
        else
        {
            str = new char[1];
            *str = '\0';
        }
    }
    ~String()
    {
        if(str != NULL)
        {
            delete[] str;
        }
        str = NULL;
    }
    
    String(const String& s)
    {
        str = s.str;
    }//浅拷贝
    
    //如何把浅拷贝变为深拷贝
    String(const String& s):str(NULL)
    {
        str = new char[strlen(s.str+1)];
        strcpy(str,s.str);
    }
    String& operator=(const String& s)
    {
        if(this != &s)
        {
            delete[] str;
            str = new char[strlen(s.str)+1];
            strcpy(str,s.str);
        }
        return *this;
    }
    String& operator=(const String& s)
    {
        if(this != &s)
        {
            //delete[] str;
            //str = new char[strlen(s.str)+1];
            //strcpy(str,s.str);
            delete[]str;
            new (this)String(s);
        }
        return *this;
    }
};
int main()
{
    String s1("yhping");
    String s2("hello");
    s2 = s1;
}

class String
{
   char* str;
   String(char* p,int)
   {
       str = p;
   }
public:
   String(const char* p = NULL):str(NULL)
   {
       if(p != NULL)
       {
           str = new char[strlen(p) + 1];
           strcpy(str,p);
       }
       else
       {
           str = new char[1];
           *str = '\0';
       }
   }
   ~String()
   {
       if(str != NULL)
       {
           delete[] str;
       }
       str = NULL;
   }
   
   
   //如何把浅拷贝变为深拷贝
   String(const String& s):str(NULL)
   {
       str = new char[strlen(s.str+1)];
       strcpy(str,s.str);
   }
   String& operator=(const String& s)
   {
       if(this != &s)
       {
           delete[] str;
           str = new char[strlen(s.str)+1];
           strcpy(str,s.str);
       }
       return *this;
   }
   String operator+(const String& s)const
   {
       char* p = new char[strlen(this->str)+strlen(s.str)+1];
       strcpy(p,this->str);
       strcat(p,s.str);
       return String(p,1);//p所指向的空间没有释放，发生内存泄漏
   }
   String operator+(const char* s)const
   {
       char* p = new char[strlen(this->str)+strlen(s)+1];
       strcpy(p,this->str);
       strcat(p,s);
       return String(p,1);
       
       //return *this+String(s);
   }
   
   //String operator+(const String& s)const
   //{
       //char* p = new char[strlen(this->str)+strlen(s.str)+1];
      // strcpy(p,this->str);
       //strcat(p,s.str);
       //return String(p);//p所指向的空间没有释放，发生内存泄漏
   //}
   
   
   String(String&& s);
   String& operator=(String&& s);
};
ostream& operator<<(ostream& out,const String& s)
{
   s << out;
   return out;
}
String operator+(const char*p,const String& s)
{
   return String(p)+s;
}
String fun()
{
   String s2("yhping");
   return s2;
}
int main()
{
   String s1;
   s1 = fun();
   return 0;
}





int main()
{
   String s1("yhping");
   String s2("hello");
   String s3;
   s3 = s1 + s2;
   s3 = s1 + "newdata";
   s3 = "newdata" + s1;
}

左值，将亡值，右值，纯右值

整个程序在运行过程中，空间利用率如何达到最大化？

虚拟内存，堆区的管理

CAS问题

无锁

除了加锁还有其他方式可以实现线程安全吗？

无锁队列，无锁栈

喝可乐的猫?
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
pta 2019乙级春赛 性感素数
忘梦心的博客
05-08 720
性感素数 “性感素数”是指形如 (p, p+6) 这样的一对素数。之所以叫这个名字，是因为拉丁语管“六”叫“sex”（即英语的“性感”）。（原文摘自 http://mathworld.wolfram.com/SexyPrimes.html） 现给定一个整数，请你判断其是否为一个性感素数。 输入格式： 输入在一行中给出一个正整数 N (≤10^8​​ )。 输出格式： 若 N 是一个性感素数，则在一...
Mysql 与 C/C++ 开发连接方法
凉皮大大的博客
05-17 232
本篇介绍 Windows Mysql 与 C/C++ 开发的连接方法。本章节不教 SQL 语法。注重简短介绍如何实现 C/C++ 与 Mysql 之间的连接部分代码，使用命令行编译可以更好理解其原理。
2019 蓝桥杯省赛 B 组模拟赛（四） 程序设计：喝可乐
qq_41998938的博客
03-11 319
题目： 代码如下：(通过50%数据) #include&lt;bits/stdc++.h&gt; using namespace std; int main() { long long t,n,m,num; cin &gt;&gt; t; while(t--){ cin &gt;&gt; n &gt;&gt; m; if(n &lt; 4) { cout &lt;&lt; ...
信息学奥赛C++语言：可口可乐
zsbailong的博客
09-07 3670
【题目描述】 便利店给出以下的优惠：“每3个空瓶可以换1瓶可口可乐。” 现在，您准备从便利店买一些可口可乐（N瓶），您想知道您最多可以从便利店拿到多少瓶可口可乐。下图给出N=8的情况。方法是：喝完8瓶可乐之后，您有8个空瓶；您用6只空瓶去换，得到了2瓶新的可口可乐；喝完后您有4个空瓶子，因此您用3个空瓶又换了一瓶新的可乐。最后，您手上有2只空瓶，所以您不能再去换到新的可乐了。因此，您一共获得8+2...
C++ - this指针用法
xd6905的博客
01-16 4801
this指针总结
c++--类的定义
gaoxiaochan的博客
04-25 8133
17．类：是在C语言的struct类型上，增加了“成员函数”。 C的strcut可将一个概念或实体的所有属性组合在一起，描述同一类对象的共同属性。 C++进行了扩展，使得struct不但包含数据，还包含函数(方法)用于访问或修改类变量(对象)的属性。C++ 在 C 语言的基础上增加了面向对象编程，C++ 支持面向对象程序设计。类是 C++ 的核心特性，通常被称为用户定义的类型。 -->类用于指定对象的形式，它包含了数据表示法和用于处理数据的方法。类中的数据和方法称为类的成员。函数在一个类中被称为
【C++】---日期计算器
L19002S的博客
10-28 4550
【C++】–日期计算器 注：可能有时你也会被这样的问题所烦恼，你想要知道自己活了多少天的话，乍一想这该怎么计算呢，捋一捋，要计算平年闰年，每个月多少天等等等苦恼着，下面我们通过C++来实现一个日期计算器，来帮你解决这一切的烦恼。 实现功能： 1.年与年，月与月，天与天的加减法。 2.日期加减一个天数。 3.计算两个日期相隔多少天。 实现难点： 1.引用的正确使用。 2.不能很好的控制每个月份的天数...
C++-实现日志log功能
热门推荐
翟天保的博客
04-26 1万+
分享一个日志log的C++代码
c++ -- 模拟电子时钟
计算机科学与技术专业学生的成长之路
02-05 1986
2020.02.04 此精确到秒，因为有精度误差加上从计算机获取初始时间时处理比较简单，因此运行一段时间会出现较大的误差。 代码可共享 #include<iostream> #include<iomanip> #include<Windows.h> using namespace std; class Clock { private: int hour...
cgb2106-day16
cgblpx的博客
08-15 4818
标题
100-day-code
03-31
100-day-code
算法：1Day-1算法
02-14
算法 1天1算法 振作起来！ :purple_heart:
C++day15-多态 文档
10-28
C++day15-多态 文档
great-day-personal-use.zip_C++_personal
09-23
this is the codejkabdf sdgjsbgb sjg bsjbvs jsbfjkf
countyear-month-day.rar_c++计算年龄
09-23
自认问计算年龄的最详细C++，计算年月日
c++ const 的多种用途
最新发布
05-17 72
常成员函数，不能修改对象的成员变量，也不能调用类中任何非 const 成员函数。该对象为常量对象，其中的任何成员都不能被修改，不能调用其他非const成员函数。const 在 * 左边。指针指向的值不可变，即 *p 不可修改。const 在 * 右边。指针本身不可变，即 p 不可修改。参数在函数内部不可改变。
C动态内存管理
aqiangdeba的博客
05-17 200
malloccallocreallocfree原则：谁申请，谁释放，防止内存泄漏在C语言中，当你传递一个指针给一个函数时，你实际上是传递了指针的副本，而不是指针本身。这意味着，虽然你在函数内部可以通过这个指针修改指向的内存，但对于指针本身的修改（例如将它指向一个新的内存地址），这种修改不会影响到函数外部指针的值。
2024OD机试卷-手机App防沉迷系统 (java\python\c++)
WRJ_Jack的博客
05-12 76
智能手机方便了我们生活的同时，也侵占了我们不少的时间。 “手机App防沉迷系统”能够让我们每天合理地规划手机App使用时间，在正确的时间做正确的事。 它的大概原理是这样的： 1. 在一天24小时内，可以注册每个App的允许使用时段 2. 一个时间段只能使用一个App，举例说明：不能同时在9:00-10:00注册App2和App3 3. App有优先级，数值越高，优先级越高。注册使用时段时，如果高优先级的App时间和低优先级的时段有冲突，则系统会自动注销低优先级的时段，如果App的优先级相 同，则后添加的Ap
C++复习 -- 类的实现
mx_jun的博客
05-13 1073
C++ 中的类（class）是一种编程结构，用于创建对象。这些对象可以拥有属性（即数据成员）和行为（即成员函数或方法）。类的概念是面向对象编程的核心之一，其主要目的是将数据和与数据相关的操作封装在一起。例如，如果你有一个“汽车”类，它可能包含颜色、品牌、型号等属性（数据成员），以及启动、停止、加速等行为（成员函数）。每当你基于这个类创建一个对象时，你就有了一个具体的汽车，具有这些属性和行为。
c++练习3-5：打印日历
04-25
if ((i + first_day_of_week) % 7 == 0 || i == days_in_month) { printf("\n"); } } } int main() { int year, month; printf("请输入年份和月份（格式：年份 月份）："); scanf("%d %d", &year, &month); ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值