C++实验一：移动语义

于 2023-05-26 10:09:51 发布
阅读量188 收藏 1
点赞数
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Seraph_V/article/details/130880652
版权

代码仅供参考
基本功能已实现，代码可自由复制、修改、转载。

课程名称： 面向对象技术(C++)
实验项目： 移动语义
实验仪器： 计算机

实验目的

1. 验证左值与右值的区别；验证右值引用的使用；

2. 设计并验证移动构造函数和移动复制函数的定义与使用，及其带来的效率提升；

实验内容 

1. 参考std::string，设计并实现MyString类。

基本功能要求：

1）四种构造函数、析构函数；

2）重载赋值操作符=，使其正确完成String类型的赋值操作；

3）重载必要的操作符，实现形如 String a = “Hello ”; a += “World!”;的功能。

4）重载必要的操作符，实现形如 String a, b, c;  c = a + b; 的操作过程。

5）重载必要的操作符，当完成 

    String a(“Hello ”);

    a << “world”;

   的操作过程后，a所代表的字符串为”Hello world”。

6）重载必要的操作符，当完成

   String a(“test”);

   std::cout << a; 的操作过程后，在屏幕上输入 test

7）重载必要的操作符，当完成

   String a(“test”);

   a[2] = ’S’; 后，a所代表的字符串为”teSt”。

设计及性能要求：

尽可能的高效实现上述MyString类。要给出关于设计思想的描述或是对设计过程做出必要说明和解释。

（一）函数

#include <iostream>
#include<string.h>
#include <chrono>
using namespace std;
class MyString{
public:
    char *_str{nullptr};
    int _length=0;
    public:
        int getl(){
            return _length;
        }
    MyString()=default;
    ~MyString(){//析构函数

        delete[] _str;

    };
   MyString(const char* str){
       if(str==nullptr)
       return;
       _length=strlen(str);
       _str=new char[_length+1];
       strcpy(_str,str);
   }
   //拷贝构造函数
   MyString(const MyString& other):_length{other._length}{
       if(other._str==nullptr)return;

       _str=new char[_length+1];
       strcpy(_str,other._str);
}
    //移动构造
    MyString(MyString &&other):_length{other._length},_str{other._str}{
    other._length=0;
    other._str=nullptr;
    }

    MyString operator+(const MyString &str){
        MyString result;
        result._length=_length+str._length;
        result._str=new char[result._length+1];
        strcpy(result._str,_str);
        strcat(result._str,str._str);
        return result;
    }
   MyString operator +=(char * str){
       _length=strlen(str)+_length;
       char *t=_str;

       _str=new char[_length+1];
       strcpy(_str,t);
       strcat(_str,str);
        delete []t;
        return *this;

   }

    MyString& operator=(const MyString &str){
        delete []_str;
        _length=str._length;
        _str=new char[_length+1];
        strcpy(_str,str._str);
        return *this;
}
    MyString &operator=(char *str){
        _length=strlen(str);
        delete [] _str;
        _str=new char[_length+1];
        strcpy(_str,str);
        return *this;
    }


 friend std::ostream&  operator<<(std::ostream& os, const MyString& str) {
        os << str._str;
        return os;
    }
     char& operator[] (int index) {
        if (index < 0 || index >= _length) {
            cout << "索引越界\n";
            exit(1);
        }
        return _str[index];
    }
};


int main()
{
    MyString s1;
    s1=("哥们名叫丁真!");
    cout<<s1<<endl;
    MyString s2="Smoke cigarettes by rules,";
    cout<<s2<<endl;
    s2+="我的小马名字叫珍珠。";
    cout<<s2<<endl;
    MyString a,b,c;
    b="假烟发现就跑路\n";
    c="Baby I ain't smoking by your rules";
    a=b+c;
    cout<<a<<endl;
    MyString s3("臭要饭的别挡我财路\n");
    s3<<"Why you always so poor";
    cout<<s3<<endl;
    MyString end("zood");
    cout<<end<<endl;
    end[0]='Z';
    cout <<end;



    return 0;
}

2.编写相应的测试用例，验证上述功能（包括内存使用的正确性）。

 

3.编写相应的测试用例，验证移动语义带来的效率提升，并给出分析与解释。

  • 实验过程

1）构造函数：接受一个 char* 类型的字符串作为参数，创建一个 MyString 类型的对象。

MyString(const char* str){

       if(str==nullptr)

       return;

       _length=strlen(str);

       _str=new char[_length+1];

       strcpy(_str,str);

   }

2）拷贝构造函数：接受一个 MyString 类型的对象作为参数，创建一个新的 MyString 类型的对象，它的值与参数对象相同。

   //拷贝构造函数

   MyString(const MyString& other):_length{other._length}{

       if(other._str==nullptr)return;

       _str=new char[_length+1];

       strcpy(_str,other._str);

}

  1. 移动构造函数：接受一个右值引用的 MyString 类型对象作为参数，创建一个新的 MyString 类型的对象，它的值与参数对象相同，并将参数对象的指针置为 null。

 //移动构造

    MyString(MyString &&other):_length{other._length},_str{other._str}{

    other._length=0;

    other._str=nullptr;

    }

  1. 拷贝赋值运算符：接受一个 MyString或char* 类型的对象作为参数，将当前对象的值设置为参数对象的值。

MyString operator +=(char * str){

       _length=strlen(str)+_length;

       char *t=_str;

       _str=new char[_length+1];

       strcpy(_str,t);

       strcat(_str,str);

        delete []t;

        return *this;

   }

    MyString& operator=(const MyString &str){

        delete []_str;

        _length=str._length;

        _str=new char[_length+1];

        strcpy(_str,str._str);

        return *this;

}

    MyString &operator=(char *str){

        _length=strlen(str);

        delete [] _str;

        _str=new char[_length+1];

        strcpy(_str,str);

        return *this;

    }

5)连接赋值运算符：接受一个 char* 类型的字符串作为参数，将其拼接到当前对象的末尾，并返回当前对象的引用。 

 MyString operator +=(char * str){

       _length=strlen(str)+_length;

       char *t=_str;

       _str=new char[_length+1];

       strcpy(_str,t);

       strcat(_str,str);

        delete []t;

        return *this;

   }    }

  1. 输出运算符：重载 << 运算符，用于将 MyString 类型的对象输出到标准输出流。MyString operator<< (char *str){

         _length=strlen(str)+_length;

       char *t=_str;

       _str=new char[_length+1];

       strcpy(_str,t);

       strcat(_str,str);

        delete []t;

        return *this;

索引运算符：重载 [] 运算符，接受一个整数类型的索引作为参数，返回当前对象中对应位置的字符。

public:friend std::ostream&  operator<<(std::ostream& os, const MyString& str) {

        os << str._str;

        return os;

    }

  

  • 功能验证

int main()

{

    MyString s1;

    s1=("哥们名叫丁真!");

    cout<<s1<<endl;

    MyString s2="Smoke cigarettes by rules,";

    cout<<s2<<endl;

    s2+="我的小马名字叫珍珠。";

    cout<<s2<<endl;

    MyString a,b,c;

    b="假烟发现就跑路\n";

    c="Baby I ain't smoking by your rules";

    a=b+c;

    cout<<a<<endl;

    MyString s3("臭要饭的别挡我财路\n");

    s3<<"Why you always so poor";

    cout<<s3<<endl;

    MyString end("zood");

    cout<<end<<endl;

    end[0]='Z';

    cout <<end;

    return 0;

}   

性能测试

MyString s1("Hello");

    int n_iterations = 10000000;

    {

        auto start = std::chrono::high_resolution_clock::now();

        for (int i = 0; i < n_iterations; ++i) {

            MyString s2(s1);    //调用拷贝构造函数

        }

        auto end = std::chrono::high_resolution_clock::now();

        std::chrono::duration<double> elapsed_seconds = end - start;

        std::cout << "Time taken by " << n_iterations << " copy constructor calls: "

                  << 1000.0 * elapsed_seconds.count() << "ms\n";

    }

    {

        auto start = std::chrono::high_resolution_clock::now();

        for (int i = 0; i < n_iterations; ++i) {

            MyString s3(std::move(s1));    //调用移动构造函数

        }

        auto end = std::chrono::high_resolution_clock::now();

        std::chrono::duration<double> elapsed_seconds = end - start;

        std::cout << "Time taken by " << n_iterations << " move constructor calls: "

                  << 1000.0 * elapsed_seconds.count() << "ms\n";

    }

Seraph_V664
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
面向对象程序设计第二次实验课——mystring类实现
nNbS
05-09 866
#pragma once #include <cstring> #include <iostream> using namespace std; const size_t MAX_CHAR_IN_NODE = 100; // 定义链块 struct Node { char s[MAX_CHAR_IN_NODE]; Node *next; };class myString; mySt
C++实验打包下载
11-06
此外，C++11及后续标准引入了许多新特性，如lambda表达式、auto关键字、右值引用、移动语义等，这些都大大提升了C++的现代性和易用性。实验将涵盖这些新特性，帮助你跟上C++的发展步伐。 在实践中，你可能还会遇到...
介绍一个模拟std::string的类
Sun_Moon_Stars的专栏
11-22 1105
        今天我们来编写一个模拟C++标准库中std::string的类。       大家都知道，在C++标准库中有一个string类，提供了一系列字符串相关的操作，简洁、方便、可靠。但是，如果由于种种原因，我们无法得到STL的支持怎么办？求人不如求己，让我们自己设计一个类（名为MyString），模仿std::string的功能，同时复习一下相关的语言知识吧！ 1 数据成
简单实现—Mystring
qq_47610967的博客
08-11 1192
运算符重载。简单实现mystring
C++ MyString类的实现
han_lx_的博客
04-07 2738
功能要求： 功能1.0 初步实现MyString类（数据属性包括char*list，intlength（字符串长度）） 1.1. 实现构造函数（通过字符串初始化list） 1.2. 析构函数 1.3. 字符串拼接 1.4. 字符串比较大小（实现strcmp功能） 1.5. 子串查找 1.6. 提取某个位置字符 1.7. 输出。 功能2.0 2.1. 流输入>>和流输出<<运算符的重载 2.2. 重载 = 运算符 2.3. 重载 += 运算符 2...
小班作业：MyString类的实现
最新发布
obstacle19的博客
11-20 681
HNU第六次的小班作业，MyString类的实现捏
C++V4实验Windows.zip
09-11
3. **右值引用（Rvalue References）**：右值引用是C++11引入的新特性，用于支持移动语义，提高对象的拷贝效率。例如，`std::move`函数可以将一个对象的控制权转移给另一个对象。 4. **lambda表达式（Lambda ...
C++jiqunfuwuqi
05-10
9. **C++11及其后续版本**：C++11引入了许多新特性，如右值引用、lambda表达式、自动类型推断（auto关键字）、移动语义等，增强了语言的现代性和效率。C++14和C++17继续扩展这些特性，如变量模板、fold表达式等。 ...
c语言c++上机实验资料
10-31
6. **C++11及以后的新特性**：C++11引入了许多新特性，如右值引用、lambda表达式、自动类型推断（auto）、移动语义等，提升了C++的现代性和易用性。 对于初学者来说，上机实验是至关重要的，它能帮助你将理论知识...
22081-11-4 仿照string类，写一个my_string类
wyl2333的博客
11-04 240
仿照string类，写一个my_string类
C++ 参考string类完成my_string类
weixin_60354809的博客
11-12 135
【代码】C++ 参考string类完成my_string类。
Mystring类的实现
qq_68623886的博客
08-12 484
string类的实现 =、[ ]等
移动语义带来性能优化效果
weixin_39703605的博客
01-26 587
这篇博客对移动语义，这一c++11新特性，带来的性能优化进行讨论，内附可编译通过的例程。
Learn C++学习笔记：第M章—移动语义和复制语义：为什么移动语义效率更高 & 怎么进行移动std::move
weixin_39548859的博客
02-22 584
移动语义效率更高 前面讲到，之所以采用移动，原因①是为了避免多个智能指针指向同一个内存，导致的释放问题。除了这个优点之外，还有原因②移动语义还比复制语义多一个优点，效率更高。 具体来看一个例子： template<class T> class Auto_ptr3 { T* m_ptr; public: Auto_ptr3(T* ptr = nullptr):m_ptr(ptr){} ~Auto_ptr3(){delete m_ptr;} // 复制语义，进行深拷贝，避免重新释放内存
基础中的基础——MyString类实现
客户端和游戏技术
05-25 3263
MyString 类是学习 C++ 的过程中一个很重要的例子，涉及到面向对象的封装、堆内存申请和释放、函数的重载以及 C++ 的 “Big Three”。本例子重点在于复习和理解上述的 C++ 特性，实现的功能并不多。 MyString 类的 Header MyString 的声明中包含了一个带指针的 C++ 类应有的函数，并且包含了一些常用的功能。其中终点讨论一下用 friend 关键字...
C++基础之四个默认函数(构造，析构，拷贝构造，赋值运算符重载)
T、的博客
12-12 558
作用： 拿一个已存在的对象来给另一个已存在的对象赋值 const 1.防止修改实参的值 2.接收隐式生成临时对象 CGoods& operator=(const CGoods& rhs) { if(this == &rhs)//如果相等便是相同对象 { return *this; } mname = rhs.mname; mprice = rhs.mprice...
手动实现String类——MyString类
userkiller的博客
07-27 895
MyString.h #ifndef _MYSTRING_H #define _MYSTRING_H #include "iostream" using namespace std; class MyString { private: int m_len; char *m_data; public: MyString(); MyString(char *str); MyStri...
仿照String类，实现简易版MyString类
吉祥如意的博客
08-05 697
设计的效果： 自用 还可以和vector一起用 调用方法 MySTL::LiteString s; cout << "s\n" << "IsEmpty() " << s.empty() << endl << endl; MySTL::LiteString s2("hello world\0"); cout << "s2\n" << s2 << endl; cout << "s2 opera
c++类的四种构造函数和析构函数(注.实例Boy类)
qq_45569601的博客
02-12 706
c++类的四种构造函数和析构函数(注.实例:Boy类) 一。提要 1.构造函数的作用初始化对象的数据成员（仅c11新标准支持类内初始化）类内初始化较为单一，不能满足复杂多变的实际要求。 2.创建一个对象时就会调用构造函数，在对象销毁前（大括号是作用域）会自动调用析构函数（释放构造函数分配的动态的动态内存空间）【不能自己手动调用构造函数和析构函数】 3.没有定义构造函数和析构函数就会调用编译器合成的...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值