左移运算符重载
#include<iostream>
using namespace std;
class Human{
public:
int x;
int y;
Human(int x1,int y1):x(x1),y(y1){};
};
//左移运算符重载,用到ostream
ostream& operator<<(ostream& stream, const Human& other){//第一个参数固定,第二个参数才是传进来的参数
cout<<
"x:"<<other.x<<
" "
<<"y:"<<other.y<<endl;
return stream;
}
int main(){
Human h1(1,2);
Human h2(3,4);
cout<<h1<<h2<<endl;
return 0;
}
运行结果:
x:1 y:2
x:3 y:4
c++浅拷贝
浅拷贝理解一
#include <iostream>
#include <string>
using namespace std;
int main(){
int *a = new int(1);
int *b = a;//此时b和a指向同一块地址,改b的值就会改a,这称为"浅拷贝"
*b=2;
cout <<"b:"<< *b << ",a:" << *a<<endl;
cout<<"hello world"<<endl;
return 0;
}
运行结果:
b:2,a:2
hello world
浅拷贝理解二
#include <iostream>
#include <stdio.h>
#include <cstring>
using namespace std;
class String{
private:
char *m_str;
unsigned int m_size;
public:
String(const char* str){
m_size = strlen(str);
m_str = new char[m_size+1];
memcpy(m_str,
str,
m_size+1);//目的地,来源,大小
}
char& operator[](unsigned int index){
return m_str[index];
}
friend ostream& operator<<(ostream& stream, const String& str);
};
ostream& operator<< (ostream& stream, const String& str){
cout<<str.m_str<<endl;
return stream;
}
int main(){
String str1 = "hello__world";
String str2 = str1;
str2[0] = 'p';
cout<<str1<<str2<<endl;
return 0;
}
运行结果:
pello__world
pello__world
解释:只复制了指针,但没有复制指针指向的结果
浅拷贝总结
浅拷贝就是:
比如有a,b两个变量
b和a指向了同一块地址,
b发生更改,a也跟着变;
a发生更改,b也跟着变.
我们想要的并不是浅拷贝这样的结果 , 而是a,b互不干扰,
即a变,b不变
b变,a不变
怎么做到呢?=======>c++深拷贝:使用拷贝构造函数
c++深拷贝:使用拷贝构造函数
深拷贝:有a,b两个变量,
int a=1; int b;
b要拷贝a的,就给b重新申请一个空间,
让他们俩互不干扰
/*关键代码:其实就是,
先重新申请一段空间,再进行memcpy拷贝,
就能完成深拷贝!!!*/
/*拷贝构造函数*/
String(const String& other)
:m_size(other.m_size)
{
m_str = new char[m_size+1];
memcpy(m_str,
other.m_str,
m_size+1);//来源,目的地,大小
}
/*拷贝构造函数*/
完整代码:
#include <iostream>
#include <stdio.h>
#include <cstring>
using namespace std;
class String{
private:
char *m_str;
unsigned int m_size;
public:
String(const char* str){
m_size = strlen(str);
m_str = new char[m_size+1];
memcpy(m_str,
str,
m_size+1);//来源,目的地,大小
}
~String(){}
/*拷贝构造函数*/
String(const String& other)
:m_size(other.m_size)
{
m_str = new char[m_size+1];
memcpy(m_str,
other.m_str,
m_size+1);//来源,目的地,大小
}
/*拷贝构造函数*/
char& operator[](unsigned int index){
return m_str[index];
}
friend ostream& operator<<(ostream& stream, const String& str);
};
ostream& operator<< (ostream& stream, const String& str){
cout<<str.m_str<<endl;
return stream;
}
int main(){
String str1 = "hello__world";
String str2( str1 );
str2[0] = 'p';
cout<<str1<<str2<<endl;
return 0;
}
运行结果:
hello__world
pello__world
深拷贝总结
从用法上来讲:
浅拷贝就是:
直接memcpy拷贝
深拷贝就是:
先重新申请一段空间,
再进行memcpy拷贝
从安全性上来讲:
如果在析构函数中,delete类对象,
浅拷贝
就会报错 .
因为,
b浅拷贝了a,
a和b共用一段存储空间,
但会delete两次.
在第一次delete完毕之后,已经没有类对象,需要delete,
第二次delete就会释放NULL空间,
自然会报错!!!
如果在析构函数中,delete类对象,
深拷贝
不会报错 .
因为,
b深拷贝了a,
a和b各自用各自的存储空间,
当析构函数delete时,
a和b会delete自己的空间,
不会报错!!!