测试string类作栈内对象返回时其gcc和VC6.0编译器的处理方式，以及测试move操作

最新推荐文章于 2020-02-27 10:10:42 发布
最新推荐文章于 2020-02-27 10:10:42 发布
阅读量135 收藏
点赞数
分类专栏： C++基础语法测试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhjixi495/article/details/102954705
版权 
/*
1.gcc编译运行结果
[root@VM_0_7_centos test]# g++ --std=c++17  mystring.cpp 
[root@VM_0_7_centos test]# ./a.out  1
String ctor: null
String ctor: two
String ctor: three
String copy ctor: two
a.c_str() = 
b.c_str() = two
d.c_str() = three
e.c_str() = two
ctor_cnt1= 4
String ctor: one
String move ctor: one
String dtor: null
------------
String copy ctor: one
ctor_cnt2= 6
String copy ctor: two
ctor_cnt3= 7
String move ctor: two
ctor_cnt4= 7
String operator= : two
ctor_cnt5= 7
a.c_str() = two
b.c_str() = two
d.c_str() = three
---String g(std::move(a))---
String ctor: null
String move ctor: two
g.c_str() = two
String dtor: two
it.c_str() = one
it.c_str() = two
After copy, str is "Hello"
After move, str is ""
The contents of the vector are "Hello", "Hello"
String dtor: one
String dtor: two
String dtor: null
String dtor: three
String dtor: two
String dtor: null
ctor_cnt= 8
dtor_cnt= 8



2.VC6.0 运行结果
String ctor: null
String ctor: two
String ctor: three
String copy ctor: three
String dtor: three
String copy ctor: two
a.c_str() =
b.c_str() = two
d.c_str() = three
e.c_str() = two
String dtor: two
String dtor: three
String dtor: two
String dtor:
ctor_cnt= 5
dtor_cnt= 5
Press any key to continue

结论：gcc 默认会开启rov优化，有些可以不用进行拷贝构造函数提高效率

*/

#include <iostream>
#include <string.h>
#include <vector>

using namespace std;

int ctor_cnt = 0;
int dtor_cnt = 0;
bool ismove = 0;

class String{
    public:
        friend ostream& operator<< (ostream&,String&);//重载<<运算符  
        friend istream& operator>> (istream&,String&);//重载>>运算符  
    
        String(const char* ptr = NULL); //通配构造函数
        String(const String& str); //拷贝构造函数
		String& operator=(const String & str);//=运算符重载
		#ifdef __GNUC__
		String& operator=(String&& other);
		#endif
        size_t size() const; //获取字符的长度
        const char* c_str();//转化成c字符串
        ~String(); //析构函数
    //private:
    public:
        char* data;     //实际字符串内容
        size_t length;  //字符串的长度
};

//重载输出运算符
ostream& operator<< (ostream& os,String& str)//重载<<运算符  
{
    os<<str.data;
    return os;
}


//重载输入运算符
istream& operator>> (istream& is ,String& str)//重载>>运算符  
{
    该用法是错误的is>>str.data;
    //因为不能确定str.data和输入的字符串的大小
    char tmp[1000] = {0};
    is>>tmp;
    str.length = strlen(tmp);
    str.data = new char[str.length + 1];
    strcpy(str.data,tmp);
    return is;
    
}



//通用构造函数
String::String(const char* ptr){

    if(!ptr){
        
        data = new char[1];
        *data = 0;
        length = 0;
		cout<<"String ctor: null"<<endl;
    }else{
        length = strlen(ptr);
        data = new char[length + 1];
        strcpy(data,ptr);
		cout<<"String ctor: "<<ptr<<endl;
    }
    
	ctor_cnt++;
}


//拷贝构造函数，需要进行深拷贝
//使用方法:String s2(s1); 使用s1来初始化s2，调用该拷贝构造函数进行深拷贝
String::String(const String& str)
{
    if(!str.data){
        data = 0;
    }else{
        length = strlen(str.data);
        data = new char[length + 1];
        strcpy(data,str.data);
		data[length] = 0;
    }

	ctor_cnt++;
	cout<<"String copy ctor: "<<data<<endl;
}


String& String::operator=(const String &str)//赋值操作符4步
{
    if (this == &str) return *this;//1 自我赋值，返回自身引用

    delete[] data;//2 删除原有数据
    
    length = str.size();//3 深拷贝
    data = new char[length + 1];
    strcpy(data, str.data);

	cout<<"String operator= : "<<data<<endl;
    return *this;//4 返回自身引用
}

size_t String::size() const//获取字符的长度
{
    return length;
}

const char* String::c_str()//转化成c字符串
{
    return data;
}


String::~String() //析构函数
{
    if(data){
		cout<<"String dtor: "<<data<<endl;
        delete []data;
        data = NULL;
        length = 0;
    }
	else
	{
		cout<<"String dtor: null"<<endl;
	}
    
    dtor_cnt++;
}

#ifdef __GNUC__
// 简单的移动赋值运算符
String& String::operator=(String&& other)
{
     if (other.data)
     {
         data = std::move(other.data);
         length = std::move(other.length);
         
         other.data = 0;
         other.length = 0;
     }
     
     cout<<"String move ctor: "<<data<<endl;
     return *this;
     
}
#endif

//gcc 默认会进行rov优化，不会调用拷贝构造函数，直接把栈内的f对象提升级调用函数可用对象，避免调用拷贝构造函数及销毁栈内的c对象的效率降低操作
String make_string()
{
    String c("three");//gcc-3  VC-3 按基本原理 c对象在make_string退出时就会销毁
    return c;//gcc-3  VC-4 这个会发生拷贝构造函数，深度拷贝 
}


int test_fun()
{
	String a;//gcc-1  VC-1
	String b("two");//gcc-2  VC-2
	String d = make_string();//gcc-3  VC-4不是返回c对象，而是返回对c对象的拷贝  gcc与VC编译器有没有rov优化主要差别在这句

    String e = b;//gcc-4  VC-5
    
    
	cout <<"a.c_str() = "<<a.c_str()<<endl;
	cout <<"b.c_str() = "<<b.c_str()<<endl;
	cout <<"d.c_str() = "<<d.c_str()<<endl;
	cout <<"e.c_str() = "<<e.c_str()<<endl;
    
    
        
    #ifdef __GNUC__
    cout<<"ctor_cnt1= "<<ctor_cnt<<endl;
    std::vector<String> v2;
    v2.reserve(16);//先预分配16个，不然空间不够时，会重新分配和移动原空间，如由1-》2会发生2次拷贝构造函数
    
    a = "one";//这一步会先用创建“one”创建一个临时对象，然后再运行String& String::operator=(String&& other)进行move操作，最后再销毁临时对象
    cout<<"------------"<<endl;
    v2.push_back(a);//会调用拷贝构造函数
   
    cout<<"ctor_cnt2= "<<ctor_cnt<<endl;
    v2.push_back(b);//调用拷贝构造函数  没有v2.reserve(16);这句时，由1——》2会发生2次拷贝构造函数  vector一般每次以2幂次增长  
    cout<<"ctor_cnt3= "<<ctor_cnt<<endl;    
    a=std::move(e);//调用String& String::operator=(String&& other)进行move操作,操作完，e的指针为变成空，这行与a = e;是不一样的
    cout<<"ctor_cnt4= "<<ctor_cnt<<endl;     
    b = a; //调用 String& String::operator=(const String &str)进行赋值操作
    cout<<"ctor_cnt5= "<<ctor_cnt<<endl;    
    cout <<"a.c_str() = "<<a.c_str()<<endl;
    cout <<"b.c_str() = "<<b.c_str()<<endl;
    cout <<"d.c_str() = "<<d.c_str()<<endl;
    if (e.c_str())//这个不会打印出来，因为使用了a=std::move(e);会调用String& String::operator=(String&& other)
    {
        cout <<"e.c_str() = "<<e.c_str()<<endl;
    }
    
    std::vector<String> v3;

    if (ismove)
    {
        v3 = std::move(v2);//与v3 = v2;是有差异的，这个是不是创建新的String类，只是把v2中移到v3
    }
    else
    {
        v3 = v2;
    }
    
    
    if(ismove)
    {
        cout<<"---String g(std::move(a))---"<<endl;
        String g;
        g  = std::move(a);
            
        if (a.c_str())//这个不会打印出来，因为使用了a=std::move(e);会调用String& String::operator=(String&& other)
        {
            cout <<"a.c_str() = "<<a.c_str()<<endl;
        }
        if (g.c_str())
        {
            cout <<"g.c_str() = "<<g.c_str()<<endl;
        }
    }
    else
    {
        cout<<"---String g(a)---"<<endl;
        //String g(a);//-->String copy ctor: two
        String g(std::move(a));//-->String copy ctor: two  这个不会进行move操作，与String g(a)结果一样，编译器优化掉？
        
        if (a.c_str())
        {
            cout <<"a.c_str() = "<<a.c_str()<<endl;
        }
        if (g.c_str())
        {
            cout <<"g.c_str() = "<<g.c_str()<<endl;
        }
    }
    
    
    
    for (std::vector<String>::iterator it=v3.begin(); it!=v3.end();++it)
    {
        cout <<"it.c_str() = "<<it->c_str()<<endl;
    }
     
    #endif  
    

    #ifdef __GNUC__
    std::string str = "Hello";
    std::vector<std::string> v;
 
    // 使用 push_back(const T&) 重载，
    // 表示我们将带来复制 str 的成本
    v.push_back(str);
    std::cout << "After copy, str is \"" << str << "\"\n";
 
    // 使用右值引用 push_back(T&&) 重载，
    // 表示不复制字符串；而是
    // str 的内容被移动进 vector
    // 这个开销比较低，但也意味着 str 现在可能为空。
    // 若是这个对象后面就不再使用，如当前这种情况，可使用std::move(cb)这种方式，这种方式只会调整指针，不过通过这种操作str对象后面就不能再使用了
    /*
    //C++ 标准库使用比如vector::push_back 等这类函数时,会对参数的对象进行复制,连数据也会复制.这就会造成对象内存的额外创建, 本来原意是想把参数push_back进去就行了,通过std::move，可以避免不必要的拷贝操作。
    //std::move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存的搬迁或者内存拷贝所以可以提高利用效率,改善性能.。
    //对指针类型的标准库对象并不需要这么做.
    */
    v.push_back(std::move(str));
    std::cout << "After move, str is \"" << str << "\"\n";
 
    std::cout << "The contents of the vector are \"" << v[0]
                                         << "\", \"" << v[1] << "\"\n";
    #endif
                  
	
	return 0;
}

int main(int argc,char **argv)
{
    if (argc > 1)
    {
        ismove = bool(atoi(argv[1])&0x01);
    }
    
    
    
    test_fun();
    
    cout<<"ctor_cnt= "<<ctor_cnt<<endl;
    cout<<"dtor_cnt= "<<dtor_cnt<<endl;
    
    return 0;
}

/*
#include <iostream>
#include <string>
using namespace std;

class String
{
public:
    String(const char* str = NULL);//通用构造函数,String("abc")
    String(const String &str);//拷贝构造
    ~String();

    String& operator=(const String &str);//赋值运算符。返回引用
    String operator+(const String &str) const;
    String& operator+=(const String &str);//+=操作符。返回引用
    char& operator[](int n) const;//下标操作符。返回引用
    bool operator==(const String &str) const;

    int size() const;//字符串实际大小，不包括结束符
    const char *c_str() const;//将string转为char *

private:
    char *data;
    int length;
};

String::String(const char* str)//通用构造
{
    if (!str)
    {//为空。String a()
        length = 0;
        data = new char[1];
        *data = '\0';
    }
    else
    {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);//会拷贝源的结束符
    }
}


String::String(const String &str)//拷贝构造，深拷贝
{
    length = str.size();
    data = new char[length + 1];
    strcpy(data, str.c_str());
}

String::~String()
{
    delete[] data;
    length = 0;
}

String& String::operator=(const String &str)//赋值操作符4步
{
    if (this == &str) return *this;//1 自我赋值，返回自身引用

    delete[] data;//2 删除原有数据
    
    length = str.size();//3 深拷贝
    data = new char[length + 1];
    strcpy(data, str.c_str());

    return *this;//4 返回自身引用
}
String String::operator+(const String &str) const//+操作符3步
{//新建对象包括新空间，拷贝两个数据，返回新空间
    String newString;
    newString.length = length + str.size();
    newString.data = new char[newString.length + 1];
    strcpy(newString.data, data);
    strcat(newString.data, str.data);
    return newString;
}

String& String::operator+=(const String &str)//+=操作符5步
{//重分配新空间，拷贝两个数据，删除自己原空间，赋值为新空间，返回引用
    length += str.size();//成员length是实际长度
    char *newdata = new char[length + 1];
    strcpy(newdata, data);
    strcat(newdata, str.c_str());
    delete[] data;
    data = newdata;
    return *this;
}

char& String::operator[](int n) const
{//下标操作符，返回引用
    if (n >= length) return data[length - 1];//如果越界，返回最后一个字符
    else return data[n];
}

bool String::operator==(const String &str) const
{
    if (length != str.size()) return false;
    return strcmp(data, str.c_str())   false : true;
}

int String::size() const
{
    return length;
}

const char *String::c_str() const
{
    return data;
}

int main()
{
    char a[] = "Hello", b[] = "World!";
    String s1(a), s2(b);
    cout << s1.c_str() << endl;
    cout << s2.c_str() << endl;
    s1 += s2;
    cout << s1.c_str() << endl;
    s1 = s2;
    cout << s1.c_str() << endl;
    cout << (s1 + s2).c_str() << endl;
    cout << s1.size() << endl;
    cout << s1[1] << endl;

    if (s1 == s2)
        cout << "相等" << endl;
        
	return 0;
}
*/

/*

//std::move使用示例
//C++ 标准库使用比如vector::push_back 等这类函数时,会对参数的对象进行复制,连数据也会复制.这就会造成对象内存的额外创建, 本来原意是想把参数push_back进去就行了,通过std::move，可以避免不必要的拷贝操作。
//std::move是将对象的状态或者所有权从一个对象转移到另一个对象，只是转移，没有内存的搬迁或者内存拷贝所以可以提高利用效率,改善性能.。
//对指针类型的标准库对象并不需要这么做.


#include <iostream>
#include <utility>
#include <vector>
#include <string>
 
int main()
{
    std::string str = "Hello";
    std::vector<std::string> v;
 
    // 使用 push_back(const T&) 重载，
    // 表示我们将带来复制 str 的成本
    v.push_back(str);
    std::cout << "After copy, str is \"" << str << "\"\n";
 
    // 使用右值引用 push_back(T&&) 重载，
    // 表示不复制字符串；而是
    // str 的内容被移动进 vector
    // 这个开销比较低，但也意味着 str 现在可能为空。
    v.push_back(std::move(str));
    std::cout << "After move, str is \"" << str << "\"\n";
 
    std::cout << "The contents of the vector are \"" << v[0]
                                         << "\", \"" << v[1] << "\"\n";
}
*/

 

zhjixi495
关注
专栏目录
Qt开发经验总结
草上爬的博客
12-02 8329
增加了很多轮子，同时原有模块拆分的也更细致，估计为了方便拓展个管理。把一些过度封装的东西移除了（比如同样的功能有多个函数），保证了只有一个函数执行该功能。把一些Qt5中兼容Qt4的方法废弃了，必须用Qt5中对应的新的函数。跟随时代脚步，增加了不少新特性以满足日益增长的客户需求。对某些模块和类型及处理进行了革命性的重写，运行效率提高不少。有参数类型的变化，比如 long * 到 qintptr * 等，更加适应后续的拓展以及同时对32 64位不同系统的兼容。
图像处理之－位图(未完待續)
04-18 4127
图像处理之－位图 MD DoCumEnT: 3/16/2016 5:59:48 PM by Jimbowhy 自从发现MarkdownPad以后，就沉迷于写作，从未有过这样的浸淫，完全没有了生物钟的同期，基本上只要醒着，手眼就离不了屏幕，离不了键盘，一直敲着几近光滑的按键，那种感觉就是满足，如果要用个词来形容，我觉得 F**KING WRITING! F**KING MY LIFE! 是恰当的。生
gcc string各种神奇的崩溃
K.O Angel 的专栏
03-28 1223
写下来，防止忘记。 当发生 string内部的任何崩溃时，请尝试一下行为 将stl string库，切入stlport
深入剖析 linux GCC 4.4 的 STL string
Daemon的专栏
11-14 446
本文通过研究STL源码来剖析C++中标准模板块库std::string运行机理，重点研究了其中的引用计数和Copy-On-Write技术。 平台：x86_64-redhat-linux gcc version 4.4.6 20110731 (Red Hat 4.4.6-3) (GCC) 1. 问题提出 最近在我们的项目当中，出现了两次与使用string相关的问题。 1.1. 问题1：新代
STL中string的源码解读
随意的风的专栏
05-17 760
STL中string的源码解读398303171@qq.com 这是个人最近比较闲暇之余，对SGI STL中string分析，如果有任何理解错误，请和我联系，谢谢！ 为什么要分析string呢？我们知道大多数的编译器实现的string都各不相同（即便是同一个编译厂商在不同的版本string的实现也不一样，例如MSVC6.0和VS2005中string的实现就不一样，VC6.0中string的实现是...
图像处理之－位图
LordYao的专栏
09-17 6411
图像处理之－位图 MD DoCumEnT: 3/16/2016 5:59:48 PM by Jimbowhy 自从发现MarkdownPad以后，就沉迷于写作，从未有过这样的浸淫，完全没有了生物钟的同期，基本上只要醒着，手眼就离不了屏幕，离不了键盘，一直敲着几近光滑的按键，那种感觉就是满足，如果要用个词来形容，我觉得 F**KING WRITING! F**KING MY LIFE! 是恰当的...
SGI STL中string的源码解读（1）
ace_5201314的专栏
11-26 1796
STL中string的源码解读   Ryan peng cutezero@163.com Sunday, June 03, 2007   这是个人最近比较闲暇之余，对SGI STL中string分析，如果有任何理解错误，请和我联系，谢谢！   为什么要分析string呢？我们知道大多数的编译器实现的string都各不相同（即便是同一个编译厂商在不同的版本string的实现也不一样，
stl string 源代码分析
kevin_darkelf的专栏
10-13 7826
STL中string的源码解读   Ryan peng cutezero@163.com Sunday, June 03, 2007   这是个人最近比较闲暇之余，对SGI STL中string分析，如果有任何理解错误，请和我联系，谢谢！   为什么要分析string呢？我们知道大多数的编译器实现的string都各不相同（即便是同一个编译厂商在不同的版本
Google C++ 风格指南内容整理
网络资源是无限的
05-17 5840
Google C++ 风格指南内容整理！
VC++ 6.0编译器
06-21
VC++ 6.0的编译器支持ANSI C++标准，能够处理类、模板、异常处理、STL（Standard Template Library）等高级特性。它的编译器名为cl.exe，与链接器link.exe一起工作，将对象文件和库合并成可执行文件。 VC++ 6.0界面...
红帽子RHEL 6.0 GCC编译器rpm安装包
04-15
在Red Hat Enterprise Linux 中安装GCC编译器所需rpm包。 内有安装说明。按步骤安装即可。
Windows(Win10/8/7)环境GCC编译器
11-20
Windows(Win10/8/7)环境下配置GCC编译器，替代不可使用的VC6.0，搭配Notepad++等编辑器构建C语言编译环境，使用方法http://blog.csdn.net/fuyanhuangyan/article/details/78587548
VC++6.0编译器（命令行）
07-07
从Microsoft Visual Studio 6.0中Ripper出来的VC++编译器，花了很多精力测试它，成功！（配合ActivePerl编译openssl-0.9.8k.tar.gz完全OK） 还添加了从MASM32 V10中Ripper出来的汇编编译器ML 6.14.8444经典版。 ...
c++ cout 输出重载测试
zhjixi495的专栏
10-28 598
#include <iostream> #include <vector> using namespace std; ostream& operator<<(ostream &out,vector<int>&src) { for (vector<int>::iterator it = src.be...
类对象大小测试2
zhjixi495的专栏
02-27 278
#include <iostream> using namespace std; /* 创建对象A 创建对象BA 创建对象A 创建对象BA 销毁对象BA 销毁对象A 销毁对象BA 销毁对象A 创建对象C 创建对象BC 创建对象C 创建对象BC line=173 fun_bc1 line=178 fun_bc2 销毁对象BC 销毁对象C line=173 fun_bc1 l...
C++防函数测试
zhjixi495的专栏
10-27 264
#include <iostream> #include <deque> #include <vector> #include <algorithm> #include <functional> #include <string> #include <sstream> #include <iostream&...
C++ set 容器使用
zhjixi495的专栏
11-05 226
/* g++ set.cc --std=c++17 set 容器使用 set 内部是使用红黑树实现的,是一种平衡二叉树,所以对其插入\查找效率是非常高的,其时间复杂度是log2(n) set是STL中一种标准关联容器。它底层使用平衡的搜索树——红黑树实现，插入删除操作时仅仅需要指针操作节点即可完成， 不涉及到内存移动和拷贝，所以效率比较高。set，顾名思义是“集合”的意思，在set中元...
C++函数中返回的对象是否进行优化运行结果
zhjixi495的专栏
11-05 218
#include <iostream> using namespace std; struct Foo { Foo() { cout << "Foo ctor" << endl; } Foo(const Foo&) { cout << "Foo copy ctor" << endl; } v...
C编译器对比：Dev-C++, VC6.0, VS2010, GCC & GDB
"这篇文档详细介绍了四种不同的C编译器：Dev-C++，Visual C++ 6.0，Visual Studio 2010以及GCC & GDB，涵盖了它们的特点、优缺点以及适用场景。" 在C语言编程领域，选择合适的编译器至关重要，因为每个编译器都有其...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值