如何调用,并给出一个小例子.
11 个解决方案
#1
class A
{
public:
A(const &A a);
...
};
void f(A a);
int main()
{
A a;
f(a); //这时就会调用A::A(const &A);
}
{
public:
A(const &A a);
...
};
void f(A a);
int main()
{
A a;
f(a); //这时就会调用A::A(const &A);
}
#2
Let me see ...
#3
就是当你想用
MyClass a=b; 时,或者当你想用a(b);时(a,b都是某个你自己写的类的实例)
就最好写一个叫做拷贝构造函数的东西。它会按照你的要求完成相应的赋值工作。之所以说最好,是因为编译器会提供一个默认的拷贝构造函数,完成上面的功能。可是当类里面有动态内存分配时候,会出现问题,所以最好自己写一个,而且这样也能使你的程序更清晰
class Circle
{
public:
Circle(double r=1.,double x=0,double y=0):_r(r),_x(x),_y(y){}
Circle(const Circle c);
private:
double _r,_x,_y;
}
Circle::Circle(const Circle c)
{
_r=c._r;
_x=c._x;
-y=c._y;
}
这个例子里面,Circle(const Circle c)就是拷贝构造函数:)
MyClass a=b; 时,或者当你想用a(b);时(a,b都是某个你自己写的类的实例)
就最好写一个叫做拷贝构造函数的东西。它会按照你的要求完成相应的赋值工作。之所以说最好,是因为编译器会提供一个默认的拷贝构造函数,完成上面的功能。可是当类里面有动态内存分配时候,会出现问题,所以最好自己写一个,而且这样也能使你的程序更清晰
class Circle
{
public:
Circle(double r=1.,double x=0,double y=0):_r(r),_x(x),_y(y){}
Circle(const Circle c);
private:
double _r,_x,_y;
}
Circle::Circle(const Circle c)
{
_r=c._r;
_x=c._x;
-y=c._y;
}
这个例子里面,Circle(const Circle c)就是拷贝构造函数:)
#4
知道什么时候要写拷贝构造函数同知道如何去写一样重要!
#5
哦,原来是这样的!
#6
acange(acan) 说得对。
在这里我发表一下我个人的理解。
拷贝构造函数== operator=重载(功能上)
在这里我发表一下我个人的理解。
拷贝构造函数== operator=重载(功能上)
#7
我发现
一般自己写了拷贝构造函数的时候
也会重载operator=
有什么必然联系么?
一般自己写了拷贝构造函数的时候
也会重载operator=
有什么必然联系么?
#8
对,如果您的类需要自定义一个拷贝构造函数函数,那么它也需要自定义一个operator =.
看来您对这个问题还不是理解得很透彻,您也许要在多看看书,在实践中去体会它。
再重复一遍:知道什么时候要写拷贝构造函数同知道如何去写一样重要!
当不需要自定义拷贝构造函数函数时,不要画蛇添足。
关于如何写好拷贝构造函数函数和operator =,可以参看《effective C++》一书。
看来您对这个问题还不是理解得很透彻,您也许要在多看看书,在实践中去体会它。
再重复一遍:知道什么时候要写拷贝构造函数同知道如何去写一样重要!
当不需要自定义拷贝构造函数函数时,不要画蛇添足。
关于如何写好拷贝构造函数函数和operator =,可以参看《effective C++》一书。
#9
我不知道acange(acan)所例举的关于拷贝构造函数的例子是否正确??
acange(acan):"这个例子里面,Circle(const Circle c)就是拷贝构造函数:)"
是否应为Circle( Circle &c)???
acange(acan):"这个例子里面,Circle(const Circle c)就是拷贝构造函数:)"
是否应为Circle( Circle &c)???
#10
其实应该这样的Circle(const Circle& c)
acange(acan)的没有使用引用参数,效率会慢
而楼上的使用了引用,但是没有加上consr修饰。不能保证参数在函数内被修改,你的加上const就更好了
acange(acan)的没有使用引用参数,效率会慢
而楼上的使用了引用,但是没有加上consr修饰。不能保证参数在函数内被修改,你的加上const就更好了
#11
道理都讲得差不多了,我就来举个例子吧:
( 本例子由模板实现,支持多种数据类型 )
#include <iostream>
using namespace std;
template < typename T >
class A
{
public:
A( T x = 0, T y = 0 );
A( A &p );
T Putoutx();
T Putouty();
private:
T a, b;
};
template < typename T >
A< T >::A( T x = 0, T y = 0 )
{
a = x;
b = y;
}
template < typename T >
A< T >::A( A< T > &p )
{
a = p.a;
b = p.b;
}
template < typename T >
T A< T >::Putoutx()
{
return a;
}
template < typename T >
T A< T >::Putouty()
{
return b;
}
主函数如下:
#include "test.h"
int main()
{
double x;
cin >> x;
float y;
cin >> y;
A< double > s( x, y );
A< double > t( s );
cout << "The function used by object s: " << endl;
cout << s.Putoutx() << endl;
cout << s.Putouty() << endl;
cout << "The function used by object t: " << endl;
cout << t.Putoutx() << endl;
cout << t.Putouty() << endl;
}
代码极为美观,走过路过的都过来看看:)。
这个例子很好地对拷贝构造函数的用法进行了说明。
( 本例子由模板实现,支持多种数据类型 )
#include <iostream>
using namespace std;
template < typename T >
class A
{
public:
A( T x = 0, T y = 0 );
A( A &p );
T Putoutx();
T Putouty();
private:
T a, b;
};
template < typename T >
A< T >::A( T x = 0, T y = 0 )
{
a = x;
b = y;
}
template < typename T >
A< T >::A( A< T > &p )
{
a = p.a;
b = p.b;
}
template < typename T >
T A< T >::Putoutx()
{
return a;
}
template < typename T >
T A< T >::Putouty()
{
return b;
}
主函数如下:
#include "test.h"
int main()
{
double x;
cin >> x;
float y;
cin >> y;
A< double > s( x, y );
A< double > t( s );
cout << "The function used by object s: " << endl;
cout << s.Putoutx() << endl;
cout << s.Putouty() << endl;
cout << "The function used by object t: " << endl;
cout << t.Putoutx() << endl;
cout << t.Putouty() << endl;
}
代码极为美观,走过路过的都过来看看:)。
这个例子很好地对拷贝构造函数的用法进行了说明。
#1
class A
{
public:
A(const &A a);
...
};
void f(A a);
int main()
{
A a;
f(a); //这时就会调用A::A(const &A);
}
{
public:
A(const &A a);
...
};
void f(A a);
int main()
{
A a;
f(a); //这时就会调用A::A(const &A);
}
#2
Let me see ...
#3
就是当你想用
MyClass a=b; 时,或者当你想用a(b);时(a,b都是某个你自己写的类的实例)
就最好写一个叫做拷贝构造函数的东西。它会按照你的要求完成相应的赋值工作。之所以说最好,是因为编译器会提供一个默认的拷贝构造函数,完成上面的功能。可是当类里面有动态内存分配时候,会出现问题,所以最好自己写一个,而且这样也能使你的程序更清晰
class Circle
{
public:
Circle(double r=1.,double x=0,double y=0):_r(r),_x(x),_y(y){}
Circle(const Circle c);
private:
double _r,_x,_y;
}
Circle::Circle(const Circle c)
{
_r=c._r;
_x=c._x;
-y=c._y;
}
这个例子里面,Circle(const Circle c)就是拷贝构造函数:)
MyClass a=b; 时,或者当你想用a(b);时(a,b都是某个你自己写的类的实例)
就最好写一个叫做拷贝构造函数的东西。它会按照你的要求完成相应的赋值工作。之所以说最好,是因为编译器会提供一个默认的拷贝构造函数,完成上面的功能。可是当类里面有动态内存分配时候,会出现问题,所以最好自己写一个,而且这样也能使你的程序更清晰
class Circle
{
public:
Circle(double r=1.,double x=0,double y=0):_r(r),_x(x),_y(y){}
Circle(const Circle c);
private:
double _r,_x,_y;
}
Circle::Circle(const Circle c)
{
_r=c._r;
_x=c._x;
-y=c._y;
}
这个例子里面,Circle(const Circle c)就是拷贝构造函数:)
#4
知道什么时候要写拷贝构造函数同知道如何去写一样重要!
#5
哦,原来是这样的!
#6
acange(acan) 说得对。
在这里我发表一下我个人的理解。
拷贝构造函数== operator=重载(功能上)
在这里我发表一下我个人的理解。
拷贝构造函数== operator=重载(功能上)
#7
我发现
一般自己写了拷贝构造函数的时候
也会重载operator=
有什么必然联系么?
一般自己写了拷贝构造函数的时候
也会重载operator=
有什么必然联系么?
#8
对,如果您的类需要自定义一个拷贝构造函数函数,那么它也需要自定义一个operator =.
看来您对这个问题还不是理解得很透彻,您也许要在多看看书,在实践中去体会它。
再重复一遍:知道什么时候要写拷贝构造函数同知道如何去写一样重要!
当不需要自定义拷贝构造函数函数时,不要画蛇添足。
关于如何写好拷贝构造函数函数和operator =,可以参看《effective C++》一书。
看来您对这个问题还不是理解得很透彻,您也许要在多看看书,在实践中去体会它。
再重复一遍:知道什么时候要写拷贝构造函数同知道如何去写一样重要!
当不需要自定义拷贝构造函数函数时,不要画蛇添足。
关于如何写好拷贝构造函数函数和operator =,可以参看《effective C++》一书。
#9
我不知道acange(acan)所例举的关于拷贝构造函数的例子是否正确??
acange(acan):"这个例子里面,Circle(const Circle c)就是拷贝构造函数:)"
是否应为Circle( Circle &c)???
acange(acan):"这个例子里面,Circle(const Circle c)就是拷贝构造函数:)"
是否应为Circle( Circle &c)???
#10
其实应该这样的Circle(const Circle& c)
acange(acan)的没有使用引用参数,效率会慢
而楼上的使用了引用,但是没有加上consr修饰。不能保证参数在函数内被修改,你的加上const就更好了
acange(acan)的没有使用引用参数,效率会慢
而楼上的使用了引用,但是没有加上consr修饰。不能保证参数在函数内被修改,你的加上const就更好了
#11
道理都讲得差不多了,我就来举个例子吧:
( 本例子由模板实现,支持多种数据类型 )
#include <iostream>
using namespace std;
template < typename T >
class A
{
public:
A( T x = 0, T y = 0 );
A( A &p );
T Putoutx();
T Putouty();
private:
T a, b;
};
template < typename T >
A< T >::A( T x = 0, T y = 0 )
{
a = x;
b = y;
}
template < typename T >
A< T >::A( A< T > &p )
{
a = p.a;
b = p.b;
}
template < typename T >
T A< T >::Putoutx()
{
return a;
}
template < typename T >
T A< T >::Putouty()
{
return b;
}
主函数如下:
#include "test.h"
int main()
{
double x;
cin >> x;
float y;
cin >> y;
A< double > s( x, y );
A< double > t( s );
cout << "The function used by object s: " << endl;
cout << s.Putoutx() << endl;
cout << s.Putouty() << endl;
cout << "The function used by object t: " << endl;
cout << t.Putoutx() << endl;
cout << t.Putouty() << endl;
}
代码极为美观,走过路过的都过来看看:)。
这个例子很好地对拷贝构造函数的用法进行了说明。
( 本例子由模板实现,支持多种数据类型 )
#include <iostream>
using namespace std;
template < typename T >
class A
{
public:
A( T x = 0, T y = 0 );
A( A &p );
T Putoutx();
T Putouty();
private:
T a, b;
};
template < typename T >
A< T >::A( T x = 0, T y = 0 )
{
a = x;
b = y;
}
template < typename T >
A< T >::A( A< T > &p )
{
a = p.a;
b = p.b;
}
template < typename T >
T A< T >::Putoutx()
{
return a;
}
template < typename T >
T A< T >::Putouty()
{
return b;
}
主函数如下:
#include "test.h"
int main()
{
double x;
cin >> x;
float y;
cin >> y;
A< double > s( x, y );
A< double > t( s );
cout << "The function used by object s: " << endl;
cout << s.Putoutx() << endl;
cout << s.Putouty() << endl;
cout << "The function used by object t: " << endl;
cout << t.Putoutx() << endl;
cout << t.Putouty() << endl;
}
代码极为美观,走过路过的都过来看看:)。
这个例子很好地对拷贝构造函数的用法进行了说明。