重载构造函数和复制构造函数的区别？求大神详细解答！主要是要好理解。

重载构造函数是为了更灵活，有更多方式进行初始化。

但当你把对象A赋值给同类的或派生的B时，C++默认按位拷贝，A和B将共享内存。

有三种情况出现按位拷贝：

第一种：Myclass A=B;

第二种：fun(Myclass a); 对象作为参数传递，是按位复制的

第三种：a = fun(); 函数中使用临时对象作为返回值

定义复制构造函数避免按位复制，并保证A和B使用不同的共存，互不影响。复制构造函数只能用于初始化。

#include<iostream>

#include<string>

/

Name:

Copyright: Institute of Computer Network & Communication Technology(CCNU)

Author: ccnupq

Date: 07-10-07 13:56

Description:

/

using namespace std;

/! @class

类名:String

功能:实现String 类的构造函数、析构函数、拷贝构造函数、赋值函数,字符串相连函数等等

/

class String

{

public:

String(const char str=NULL);//构造函数

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

~String(void);//析构函数

String& operator=(const String &);//重载"=",字符转赋值

String& operator+(const String &other);//,重载"+",字符串链接

String& operator-(const String &other);//,重载"-",删除字串

bool operator==(const String &other);//重载"==",判断两个字符串相等

bool operator<(const String &other);

bool operator>(const String &other);

//重载<<,这里必须使用friend,因为涉及到两个类之间私有成员的访问

friend ostream& operator << (ostream &, const String &);

private:

char m_data;

};

//构造函数

String::String(const char str)

{

if(str==NULL)

{//无参数,默认构造一个空串

m_data=new char[1];

m_data='\0';

cout<<"调用了默认构造函数"<<endl;

}

else

{//有参数,

int length=strlen(str);

m_data=new char[length+1];

strcpy(m_data,str);

cout<<"调用了普通构造函数"<<endl;

}

}

//拷贝构造函数,用一个对象初始化另外一个对象的时候调用

String::String(const String &other)

{

int length=strlen(otherm_data);

m_data=new char[length+1];

strcpy(m_data,otherm_data);

cout<<"调用了拷贝构造函数"<<endl;

}

//析构函数

String::~String()

{

delete[] m_data;

}

//重载运算符"=" ,用一个对象赋值给另外一个对象的时候调用

String& String::operator=(const String &other)

{

if (this==&other)

return this;

delete [] m_data;

int length=strlen(otherm_data);

m_data=new char[length+1];

strcpy(m_data,otherm_data);

cout<<"重载了运算符="<<endl;

return this;

}

////重载运算符"+"

String& String::operator+(const String &other)

{

char temp[100];

strcpy(temp,m_data);

int one_length=strlen(m_data);

int other_length=strlen(otherm_data);

delete[] m_data;

m_data=new char[one_length+other_length+1];

strcpy(m_data,temp);

strcat(m_data,otherm_data);

cout<<"重载了运算符+"<<endl;

return this;

}

String& String::operator-(const String &other)

{

char temp,p;

if( (temp=strstr(m_data,otherm_data)) ==NULL)

{

cout<<"没有符合的子串,不能使用'-' *** 作"<<endl;

return this;

}

else

{

p=temp;

temp=temp+strlen(otherm_data);

p='\0';

strcat(m_data,temp);

}

cout<<"重载了运算符-"<<endl;

return this;

}

//重载运算符"<<"

ostream& operator<<(ostream &output, const String &other)

{

output<<otherm_data;

cout<<"重载了运算符<<"<<endl;

return output;

}

bool String::operator<(const String &other)

{

if(strcmp(m_data,otherm_data)<0)

return true;

return false;

}

bool String::operator>(const String &other)

{

if(strcmp(m_data,otherm_data)>0)

return true;

return false;

}

bool String::operator==(const String &other)

{

if(strcmp(m_data,otherm_data)==0)

return true;

return false;

}

/! @function

函数名:main

/

int main()

{

String s1("Hello,");

String s2("World!");

String s3(s2);//调用拷贝构造函数

String s4(s2);

String s5("Hello,World");

String s6("Hello,World!");

String s7("Hello,World!");

String s8("o,W");

String s9;

//String s3;//调用构造函数中的默认构造

//s3=s2;// 调用重载后的赋值函数

cout<<s1<<endl;

cout<<s2<<endl;

cout<<s3<<endl;

s3=s1+s2;

cout<<s1<<endl;

cout<<s2<<endl;

cout<<s3<<endl;

if(s4==s2)

cout<<"两个字符串相等"<<endl;

else

cout<<"两个字符串不相等"<<endl;

if(s5<s6)

cout<<"s5小于s6"<<endl;

else if(s5>s6)

cout<<"s5大于s6"<<endl;

else

cout<<"s5等于s6"<<endl;

s9=s7-s8;

cout<<s9<<endl;

system("pause");

}

//c++自定义类型中有个vector容器，容器里面是一些指针，如何写这个类的复制构造函数和重载=符？

#include <vector>

#include <iostream>

using namespace std;

class Element

{

public:

Element(int data) {

cout<<__FUNCTION__<<" is called"<<endl;

m_data = data;

}

~Element() {

cout<<__FUNCTION__<<" is called"<<endl;

}

void show() const {

cout<<m_data<<endl;

}

private:

int m_data;

};

class Foo

{

public:

Foo() {

cout<<__FUNCTION__<<" is called"<<endl;

}

~Foo() {

cout<<__FUNCTION__<<" is called"<<endl;

for (int i = 0; i < m_elmssize(); ++i)

delete m_elmsat(i);

m_elmsclear();

}

Foo(const Foo& other) {

cout<<__FUNCTION__<<" is called"<<endl;

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

Element p1 = otherm_elmsat(i);

Element p2 = new Element(p1);

m_elmspush_back(p2);

}

}

Foo &operator=(const Foo &other) {

cout<<__FUNCTION__<<" is called"<<endl;

if (&other != this) {

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

delete m_elmsat(i);

}

m_elmsclear();

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

Element p1 = otherm_elmsat(i);

Element p2 = new Element(p1);

m_elmspush_back(p2);

}

}

return this;

}

void addElem(Element elem)

{

m_elmspush_back(elem);

}

void show() {

cout<<"Foo::show:"<<endl;

for (int i = 0; i < m_elmssize(); ++i)

m_elmsat(i)->show();

cout<<endl;

}

private:

vector<Element > m_elms;

};

int main()

{

Foo foo1 = new Foo();;

foo1->addElem(new Element(1));

foo1->addElem(new Element(2));

foo1->addElem(new Element(3));

foo1->show();

delete foo1;

cout<<"----------------"<<endl;

foo1 = new Foo();

foo1->addElem(new Element(11));

// copy constructor called

Foo foo2 = new Foo(foo1);

foo2->addElem(new Element(8));

foo1->show();

foo2->show();

cout<<"-----------------"<<endl;

delete foo1;

foo2->show();

cout<<"-----------------"<<endl;

Foo foo3 = new Foo();;

// = called

foo3 = foo2;

foo3->show();

foo3 = foo2;

foo3->show();

return 0;

}

构造函数 是一种特殊的方法 主要用来在创建对象时初始化对象 即为对象成员变量赋初始值一个类也可以有多个构造函数，用来初始化不同形式的类。

拷贝函数是特殊的构造函数，用来完成对象初始化，即定义时赋值，下面程序中有详解。如果没有定义，系统会调用默认的拷贝构造函数，但此函数不能处理深拷贝问题，及若有new用到，系统的只是共享区域，不分配新空间。

赋值函数要用运算符重载来实现。下面有程序。

#include <iostream>

using namespace std;

class time

{

public:

time() //constructor构造函数

{

hour=0;

minute=0;

sec=0;

}

time(const time &obj) //拷贝构造函数

{

hour = objhour;

minute = objminute;

sec = objsec;

}

time& operator=(const time &obj) //运算符重载，用来完成赋值函数

{

this->hour = objhour;

this->minute = objminute;

this->sec = objsec;

return this;

}

void set_time();

void show_time();

private:

int hour;

int minute;

int sec;

};

int main()

{

class time t1; //调用time()构造函数为成员赋初值

t1show_time();

//t1set_time();

t1show_time();

time t2 = t1; //调用拷贝构造函数，为对象t2赋值

t2show_time();

time t3;

t3 = t1; //调用运算符重载=函数，为对象t3赋值

t3show_time();

return 0;

}

void time::set_time()

{

cin >>hour;

cin >>minute;

cin >>sec;

}

void time::show_time()

{

cout<<hour<<":"<<minute<<":"<<sec<<endl;

}

关于构造函数，拷贝构造函数等，百度词汇，书本上都有详解，可以认真看一下。愿学习进步！

当新对象被创建的时候，构造函数会被调用。每一个类都有构造函数。在程序员没有给类提供构造函数的情况下，java编译器会为这个类创建一个默认的构造函数。

java中构造函数重载和方法重载很相似。可以为一个类创建多个构造函数。每一个构造函数必须有它自己唯一的参数列表。

java不支持像c++中那样的复制构造函数，这个不同点是因为如果你不自己写构造函数的情况下，java不会创建默认的复制构造函数。

赋值运算符和复制构造函数都是用已存在的B对象来创建另一个对象A。不同之处在于：赋值运算符处理两个已有对象，即赋值前B应该是存在的；复制构造函数是生成一个全新的对象，即调用复制构造函数之前A不存在。

CTemp a(b); //复制构造函数，C++风格的初始化

CTemp a=b; //仍然是复制构造函数，不过这种风格只是为了与C兼容，与上面的效果一样

在这之前a不存在，或者说还未构造好。

CTemp a;

a=b; //赋值运算符

在这之前a已经通过默认构造函数构造完成。

而之所以要自定义这些，是因为防止有指针时浅拷贝造成错误。具体可百度 rule of three原则

调用cwnd的无参构造函数是生成成员变量t

你用一个整数对t赋值的时候（t=1; t=2;）实际上做了很多事情，首先，t和整数的类型不一样，编译器不能直接赋值，它会先去找int或者unsigned long和cwnd之间的关系，也就是自动寻找如何把unsigned long变成cwnd的方法，它找到了cwnd的带参数那个构造函数，然后调用它，生成一个临时对象，然后赋值。这个过程也就是自动类型转换，你可以去搜一下相关的资料。

另外，在赋值的时候由于没有重载赋值运算=，所以进行的是按位拷贝，当然这和你的问题已经无关了