老九学堂 学习C++ 第九天

于 2021-03-07 01:45:40 发布
阅读量197 收藏
点赞数
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51942099/article/details/114044298
版权

9.1 复制构造函数

例：
自定义string类，以简化字符串的操作

在这里插入图片描述
在这里插入图片描述

注：
如果不重载赋值运算符，对象str1的内容直接复制到新对象str2中，对于没有指针的简单类来说这足够了，但当我们拥有作为数据成员的指针时，逐字节的复制将会把指针从一个对象复制给另一个对象，而两个指针就会同时指向一个内存

解决方案：重载赋值运算符

在这里插入图片描述

注：

  1. 当重载赋值运算符时，务必确定将一个对象中的所有数据成员都复制到另一个对象中
  2. 如果包含多个数据成员，则每个成员都需要复制到目标对象中

另一个场景：同一个类的对象初始化另一个对象时。

String str2(str1);

解决方案：为类定义赋值 / 复制构造函数（即以对象为参数的构造函数）
//使用const关键字可以保证复制过程中不会改变被复制的对象：

String(const String & str);//复制构造 / 拷贝构造函数

注：在下面三种场景里面会调用复制的构造函数：

  1. 当类的对象被初始化为同一类的另一个对象时
  2. 当对象被作为参数传递给一个函数时
  3. 当函数返回一个对象时
//自定义的字符串包装类
class String
{
    public:
        String();
        String(char * str);
        String(const String & str);//复制构造 / 拷贝构造函数
        virtual ~String();

        //重载赋值运算符，将数组中每个元素都进行复制，而不是只复制数组指针
        const String & operator=(const String & str);
        friend ostream & operator << (ostream & out, const String & str);
    protected:

    private:
        int m_length;   //字符串的实际长度，不包括\0
        char * m_value;   //实际存储字符的字符数组

};

String::String(): m_length(0)
{
    //char * str = "";    //长度为0，但是实际的字符数组中会存在唯一的元素：\0
    this->m_value = new char[m_length + 1];
    this->m_value[0] = '\0';
}
ostream & operator << (ostream & out, const String & str)
{
    out << str.m_value << "\n";
    //out << "m_value的长度：" << strlen(str.m_value);
    printf("%p", str.m_value);
    return out;
}
String::String(char * str)
{
    //将传入的字符串str的值赋给当前对象中的m_value
    if(NULL == str){
        this->m_value = new char[1];
        this->m_value[0] = '\0';
        return;
    }
    m_length = strlen(str);//获得复制字符串的长度
    m_value = new char[m_length + 1];//为\0留出一个空间
    strcpy(m_value, str);
}

String::String(const String & str)//复制构造 / 拷贝构造函数
{
    m_length = strlen(str.m_value);
    m_value = new char[m_length + 1];
    strcpy(m_value, str.m_value);
}

//当重载赋值运算符，务必确定将一个对象中的所有数据都复制到另一个对象中（特别是有指针时）
//如果是包含多个成员，那么每个成员都需要复制到内存对象中 - 深复制
/* 如果一个成员拥有指针类型成员，那么大部分情况下，都需要使用深复制 - 才能将指针指向的内容复制一份出来，
                让原有的对象和新对象相互独立*/
//如果类的成员没有指针，那么一般使用浅复制
const String & String::operator=(const String & str)
{
    if(this == &str) return *this;
    delete[] m_value;   //首先要释放字符串的原始空间
    m_length = str.m_length;
    m_value = new char[m_length + 1];
    strcpy(m_value, str.m_value);
    return *this;
}

String::~String()
{
    //析构时，释放字符数组所指向的空间
    delete[] m_value;
}

void TestString()
{
    String str1("我是你爹");
    //String str2 = "sadwea";
    String str2(str1);
    cout << str1 << endl;
    cout << str2 << endl;

	cout << "对象之间的赋值" << endl;
    str2 = str1;
    cout << str1 << endl;
    cout << str2 << endl;
}

·

·

·

·

·

自定义数组类：

//自定义的数组类
class Array
{
    public:
        Array(int length = 0);
        Array(const Array & arr);   //拷贝构造
        virtual ~Array();
        //int operator[](int index);  //获取元素(无法写入)
        const Array & operator=(const Array & arr);
        int & operator[](int index);
        friend ostream & operator<<(ostream & out, const Array & arr);
    private:
        int m_length;
        int * m_datas;
};

Array::Array(int length): m_length(length)
{
    if(m_length == 0){
        m_datas = NULL;
    }else{
        m_datas = new int[m_length];
    }
}
Array::Array(const Array & arr)
{
    if(arr.m_length == 0) return;
    m_length = arr.m_length;
    m_datas = new int[m_length];
    //1.使用循环组个元素赋值
    //2.memcpy
    memcpy(m_datas, arr.m_datas, m_length * sizeof(int));
}
const Array & Array ::operator=(const Array & arr)
{
    if(this == &arr) return *this;
    if(arr.m_length == 0) return *this;
    m_length = arr.m_length;
    m_datas = new int[m_length];
    //1.使用循环组个元素赋值
    //2.memcpy
    memcpy(m_datas, arr.m_datas, m_length * sizeof(int));
    return *this;
}
ostream & operator<<(ostream & out, const Array & arr)
{
    for(int i = 0; i < arr.m_length; i++)
    {
        out << arr.m_datas[i] << ",";
    }
    out << endl;
}
/*
//重载中括号运算符
int Array::operator[](int index)
{
    if(m_length == 0){
        cerr << "数组为空，访问失败！" << endl;
    }
    if(index < 0 || index >= m_length){
        cerr << "数组下标越界！" << endl;
    }
    return m_datas[index];
}*/
int & Array::operator[](int index)
{
    if(m_length == 0){
        cerr << "数组为空，访问失败！" << endl;
    }
    if(index < 0 || index >= m_length){
        cerr << "数组下标越界！" << endl;
    }
    return m_datas[index];
}

Array::~Array()
{
    delete[] m_datas;
}

//测试：
void TestArray()
{
    Array arr1(10);
    arr1[0] = 1234;
    cout << arr1 << endl;
}

·

·

·

·

·

自定义容器类：

//使用了模板技术，模板技术一般用来做算法，比如重载100次某个类型的算法
//注：如果使用模板技术，那么类的声明和方法实现都要放在同一个头文件中
template<typename T>

class MyVector
{
    public:
        MyVector();
        MyVector(int len, T element); //填充len长度的元素element
        MyVector(const MyVector<T> & vec);  //复制构造
        virtual ~MyVector();

        template<typename T2>
        friend ostream & operator<<(ostream & out, const MyVector<T2> & vec);
        MyVector<T> & operator=(const MyVector<T> & vec);
        T & operator[](int index);  //获取元素
        void push_back(T element);  //将元素element添加到内部数组中
        /**
        T pop_back();   // 返回并删除最后一个元素
        void insert(int pos, T elemnt); //在pos位置处，插入元素element
        void clear();   //清空所有的元素 **/
    private:
        T * m_elements;//用来存放元素的数组
        int m_length;//所存放元素的实际个数
        int m_capacity;//当前元素数组的大小vec.m_elements
};

template<typename T>
MyVector<T>::MyVector(): m_capacity(16), m_length(0)
{
    this->m_elements = new T[m_capacity];
}
template<typename T>
MyVector<T>::MyVector(int len, T element): m_capacity(16)
{
    m_capacity = len + m_capacity;
    m_length = len;
    m_elements = new T[m_capacity];
    for(int i = 0; i < m_length; i++)
    {   //1.使用for循环复制
        //m_elements[i] = element;    //每次都会调用重载的赋值运算符
        //2.使用memcpy复制
        memcpy(&m_elements[i], &element, sizeof(T));
    }
}
template<typename T>
MyVector<T> & MyVector<T>::operator=(const MyVector<T> & vec)
{
    if(this = &vec) return *this;
    if(NULL != m_elements){
        delete[] m_elements;
        m_elements = NULL;
    }
    m_capacity = vec.m_length + vec.m_capacity;
    m_length = vec.m_length;
    m_elements = new T[vec.m_capacity];
    memcpy(m_elements, vec.m_elements, m_length * sizeof(T));
    return *this;
}
template<typename T>
void MyVector<T>::push_back(T element)
{
    //将元素element添加到内部数组的最后一个位置
    if(NULL == m_elements){
        m_capacity = 16;
        m_length = 0;
        m_elements = new T[m_capacity];
    }
    //判断当前数组的容量是否已满
    if(m_length == m_capacity){
        //如果满了，就扩容（当前容量* + 1）
        T * newElement = new T[m_capacity * 2 + 1];
        //把原来的元素拷贝到新空间
        memcpy(newElement, m_elements, m_length * sizeof(T));
        delete m_elements;  //释放空间
        m_elements = newElement;    //将元素数组指向修改为新空间
    }
    //m_elements[m_length++] = element;
    memcpy(&m_elements[m_length++], &element, sizeof(T));
}
template<typename T>
T & MyVector<T>::operator[](int index)
{
    return m_elements[index];
}
template<typename T2>
ostream & operator<<(ostream & out, const MyVector<T2> & vec)
{
    for(int i = 0; i < vec.m_length; i++)
    {
        out << vec.m_elements[i] << ",";
    }
    out << endl;
    return out;
}
//拷贝构造
template<typename T>
MyVector<T>::MyVector(const MyVector<T> & vec)
{
    m_capacity = vec.m_capacity;
    m_length = vec.m_length;
    m_elements = new T[m_capacity];
    memcpy(m_elements, vec.m_elements, m_length * sizeof(T));
}
template<typename T>
MyVector<T>::~MyVector()
{
    delete[] m_elements;
}

//测试：
void TestVector()
{
    MyVector<int> vec1;  //默认构造
    MyVector<double> vec2(10, 99.9);
    cout << "vec1" << vec1 << endl;
    cout << "vec2" << vec2 << endl;
    MyVector<String> vec3(5, String("add"));
    vec3.push_back("123");
    cout << "vec3" << vec3 << endl;
}

9.2 类型的自动转换和强制转换

在C++中存在隐式类型转换语法（自动类型转换）

int a = 12;
a = 22.2 + a;

C++还提供了显式类型转换语法（强制转换）

类型名（变量）
int num = int(88.5);

C语言采用的语法格式
int num = (int)88.5;

注：

  1. 不管是自定类型转换还是强制类型转换，前提是编译器必须知道如何转换
    ① 将浮点型数据赋值给整型变量时，舍弃小数部分
    ② 将整型数据赋值给浮点型变量时，数值不变，但是以指数形式存储
    ③ 将double型数据赋值给float变量时，注意数值范围溢出
    ④ 字符型数据可以赋值给咱整型变量，此时存入的是字符的ASCLL码
    等等…
9.2.1 自定义类型之间的转换

C++允许我们自定义类型转换规则：我们可以将其它类型转换为当前类类型，也可以将当前类类型转换为其它类型，这种自定义的类型转换规则只能以类的成员函数的形式出现

转换构造：将其他类型转换为当前类型时调用

class Rectange
{
    public:
        Rectange();
        Rectange(float width, float height);     //带参构造
        Rectange(const Rectange & rect);    //拷贝构造
        Rectange(float width);          //转换构造（将其它类型转换为当前类型时使用
        void diaplay(){
            cout << "width:" << width << endl;
            cout << "height:" << height <<endl;
        }
        /*
        //将几个构造混合在一起的写法：
        Rectange(float width = 0, float height = 0): width(width), height(height)
        {
            
        }
        */
        virtual ~Rectange();
    private:
        float width;
        float height;
};
9.2.2当前类型转换为其他类型

类型转化函数：
类型转换函数的作用就是将当前类类型转换为其它类型；它只能以成员函数的形式出现（直接在.h文件中书写），也就是只能出现在类中。

//类型转换函数的语法格式：
operator type()
{
	return data;
}

特点：

  1. 类型转换函数看起来没有返回值类型，其实是隐式地指明了返回值类型
  2. 类型转换函数也没有参数，因为要将当前类的对象转换为其它类型（实际上编译器会把当前对象的地址赋值给this指针，这样在函数体内就可以操作当前对象了）
operator float() const{//将矩形转换成float类型
    return width;
}
operator Circle() const{//将矩形转换成Circle类型
	return Circle(width / 2);
}

注：

  1. type可以是内置类型，类类型以及由typedef定义的数据别名，任何作为函数返回类型都是被支持的（不允许转换为数组或函数类型，可以转换为指针或引用类型）
  2. 类型转换函数一般不会更改被转换的对象，所以通常被定义为const
  3. 类型转换函数可以被继承，可以是虚函数
满月∅
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
老九学堂 学习 C++
m0_51942099的博客
01-29 331
第一天 c++应用范围：文字处理程序及电子表格、编译器 c++保留了C语言原有的所有优点，增加了面向对象机制，对C语言的功能做了扩充。 对C语言的扩充： 变量的定义可以出现在程序中的任何行 提供了标准输入输出流对象cin，cout 用const定义常变量 函数重载，函数模板，带默认值的函数 引用类型 单目作用域运算符 string类型字符串 使用new和delete代替malloc和free函数等 典型的C++代码HelloWorld： #include <iostream> using
老九学堂C++代码
andrewhxc的博客
08-30 1112
老九学堂 课时98 的代码上传 第98课时时长80几分钟，例程代码也是全部课中最多的，这份代码是按照讲师讲解来敲的，经测试和视频效果一样，可放心学习 打开MyCppWorkSpace---dizhu2---default.workspace(用 code blocks打开) 就可以看到全部代码。 下面是下载链接 链接: https://pan.baidu.com/s/1-kEH3e...
学习徐嵩老师（老九学堂）C++笔记（一）
weixin_43042467的博客
01-08 816
1、C语言 C语言是面向过程的结构化和模块化语言。最大问题就是没能解决软件危机的问题（代码行超过10万以上就会出现管控上的问题）。 C语言作为一门非常古老的语言,是在1972年由肯.汤普逊和Dennis Ritchie（丹尼斯.里奇）这两位联手开发。C语言基于汇编，和汇编有很亲的亲戚关系，所以也可以叫C语言半汇编半高级语言。所以C语言和计算机底层硬件有很好的沟通性，因而被用来写操作系统（比如Lin...
小白学习老九君C++笔记(5)面向对象的类与继承
weixin_42592666的博客
09-19 147
S
老九学堂C++教程的实战项目-《都市浮生记》工程文件
09-28
根据视频一步一步自己敲的，每一步都测试无误，可以使用，代码和视频展示的不完全一样，有些更改， 资源包含： 1.源码 2.exe可执行文件 3.音效文件 注释：可以使用CodeBlocks打开项目文件codeblocks.cbp
Xuetang9:老九学堂课程测试
03-30
【标题】"Xuetang9:老九学堂课程测试"是一个与编程教育相关的主题，特别是聚焦于Java语言的学习。这可能是一个在线课程平台或者教学资源集合，旨在帮助学习者掌握Java编程技能。在这个课程测试中，学员可能需要通过...
魔塔_java编写魔塔_老九学堂魔塔_魔塔java项目_魔塔谁发明的_魔塔开发_
09-29
《Java编程实现的魔塔游戏解析》 ...通过老九学堂的项目，学习者可以在实践中学习到Java语言的强大功能，同时体验到游戏开发的乐趣。无论你是编程新手还是经验丰富的开发者，挑战魔塔的实现都是一次有价值的学习经历。
C++零基础学习
07-15
C++从零开始学习：基础介绍，数据类型，C语言，面向对象，类，多态，继承
C_Study:老九堂C语言学习练习的
03-23
"老九堂C语言学习练习"是一个专门为初学者和进阶者设计的学习资源，它包含了丰富的练习题和实例代码，旨在帮助学习者深入理解和掌握C语言的核心概念。 在"老九堂C语言学习练习"中，你可以找到以下几个关键知识点： ...
小白学习老九君C++笔记(4) string函数
weixin_42592666的博客
09-19 99
string
老九学堂数据结构与算法章节1课堂笔记
qq_43233736的博客
10-10 953
基本概念 数据：描述客观事物的符号，是计算机中可以操作的对象，是能被计算机识别，并输入给计算机处理的符号集合。 （注意： 1.数据有两个特点，一是可以输入到计算机中二是能够被计算机程序处理 2.数据不仅仅包括整型，实型等数值类型还包括字符及声音图像视频等非数值类型） 数据元素：组成数据，有一定意义的基本单位在计算机中通常作为整体处理也被称为记录 数据项：一个数据元素可以由若干个数据项组成（数...
老九学堂【C++】保留字[关键字]
arkliszeng的专栏
10-21 226
Hi~小伙伴，今天老九君给大家分享一些C++中比较常用和常见的一些保留字[关键字]。 在C++中现存74个关键字/保留字。常用的关键字如下[点击图片可查阅]: 除了这些关键字，C++中提供的所有关键字如下。咱们这里不再过多阐述： 本笔记介绍了C++中的常用的一些关键字，也将C++11中全部关键字列出，小伙伴们自行查阅学习哦。 遇到问题，可加老九君个人QQ：614940318，请备注来自CSDN 老九学堂免费C、C++、Java课程地址：https://study.163....
【老九学堂】【C++】编译器之Eclipse安装配置
LaoJiuJun的博客
08-08 456
C++编译器之Eclipse安装配置 小伙伴们，你们造吗？除了CodeBlocks和VS、Clion等等开发工具外，我们开发Java常用的Eclipse也可以来开发C++！！下面老九君就给大家简单的讲解下如何使用Eclipse的C++集成版来搭建标准的C/C++开发环境，以及打印出“Hello world！”。 首先，我们需要3种“原材料”： 1.Eclipsefor C++，即C++集成版的Ec...
【老九学堂】【C++】编码&命名规范
arkliszeng的专栏
10-15 171
1.命名规范 关于命名规范我们常用于本地变量名、全局变量名、预处理指令名称、函数名称、命名空间名称、类名、成员变量名称、成员函数名称。 1.1 通用命名规范. 在开发的时候命名尽量使用描述性的命名。这样的命名更加有助于别人快速的理解。比如: 关于缩写，除非是大家都能够看得懂的缩写。否则尽量不要使用缩写。 1.2 本地变量 通常情况下变量名一律小写。单词以下划线链接。如: 1.3 全局变量 对于全局变量的...
老九学堂标准c++代码拆分
Riverhope的博客
01-27 1273
#include using namespace std; int main() { cout << "Hello World"<<endl return 0; }  iostream(input & output stream) using namespace std; 告诉编译器使用命名空间 std（standard） 。命名空间是 C++ 中一个相对新的概
老九学堂 学习 C++ 第五天
m0_51942099的博客
02-02 174
指针 基本概念：指针（pointer）是一个值为内存地址的变量（或数据对象） 声明及初始化指针变量 基本用法：数据类型 * 指针变量名 int * ptr_num; char * ptr_name; float * money_ptr; 注： int* p的写法偏向于地址，即 p 就是一个地址变量，表示一个十六进制地址 int *p的写法偏向于值， *p是一个类型变量，能够表示一个整型值 声明中的 * 号和使用中的 * 号含义完全不同 空指针(null poiniter) 空指针：空指针不指向任何对
c++新手部分总结
抒情诗
04-14 141
20年上半年c++   1.函数运用在程序中会大大减少程序员的代码量。   2.函数传参：值传递，引用传递，指针传递。只有值传递不会对实参的值产生影响。   3.函数传参时可以传递数组，而在函数中对数组的改变同样会影响实际的数组里的元素。   4.应用传递数组的函数时，只需输入数组名就行了。不需要带上[方括号]。   5.下面五个是字符串库的函数 6.strcpy(s1, s2); 复制字...
【老九学堂】【C++】位运算符
LaoJiuJun的博客
08-08 624
位运算是指按二进制进行的运算。在系统软件中，常常需要处理二进制位的问题。C语言提供了6个位操作运算符。这些运算符只能用于整型操作数，即只能用于带符号或无符号的char,short,int与long类型。 C语言提供的位运算符列表： 1、“按位与”运算符（&） –按位与是指：参加运算的两个数据，按二进制位进行“与”运算。如果两个相应的二进制位都为１，则该位的结果值为1；否则为0。这里的1可...
qlabel显示两行_QLabel 类(老九学堂C++会员友情翻译，不喜勿喷)
最新发布
06-01
您可以使用QLabel的setWordWrap()函数来实现多行显示。将其设置为True即可自动换行。下面是一个示例代码： ``` QLabel *label = new QLabel(this); label->setText("这是一个需要显示两行的文本，可以通过设置QLabel的WordWrap属性来实现自动换行。"); label->setWordWrap(true); ``` 此代码将创建一个QLabel并将其设置为显示两行文本。请注意，如果文本的长度超过QLabel的宽度，则仍然需要手动调整QLabel的宽度才能完全显示文本。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值