拷贝构造函数与运算符的重载
* 多态
- 前堤:继承,虚函数,指针或引用
- 类型转换 : dynamic_cast 把父类*转换成子类*
- 纯虚函数 : 保证此函数一定不会被执行,抽象类,不能创建对象.
* 友元
- 内部授权,不是成员,这一点很重要,因此也没有this,与之相关的一切
也没有.
- 打破封装,必须有一个类的内部声明,可访问任何成员通过 对象.来访
问.
* 静态
- 是成员
- 大家共用一份成员,整个类共用的成员.
- 静态数据成员: 在外部初始化
- 静态函数只能访问静态成员,类名::成员
====================================================
* 运算符重载(c++特有功能)
* 内部类
* 异常
拷贝构造函数除了名字特殊外毫无特殊之处.如下
C++代码
A(const A& obj){
cout << "我是拷贝构造函数" << endl;
}
A a = obj// 与 A a(obj)是等价的
C++代码
#include <iostream>
using namespace std;
class A {
int data;
public :
A():data(5){ //初始化列表初始化的是成员而不是形参
cout << "A()" << endl;
}
A(int d):data(d){
cout << "A(int)" << endl;
}
A(bool b):data(b?123:234){
cout << "A(bool)" << endl;
}
A(char c) : data((int)c){
cout << "A(char)" << endl;
}
A(const A& o) : data(o.data){
cout << "A(const A&)" << endl;
}
void show(){
cout << "data=" << data << endl;
}
virtual ~A(){
cout << "~A()" << endl;
}
};
int main()
{
A a1;//调用无参构造函数
A a2(28);
A a3(true);
A a4('S');
A a5(a2);
}
//用引用的好处
#include <iostream>
using namespace std;
class A {
int data;
public :
A():data(5){ //初始化列表初始化的是成员而不是形参
cout << "A()" << endl;
}
A(int d):data(d){
cout << "A(int)" << endl;
}
A(bool b):data(b?123:234){
cout << "A(bool)" << endl;
}
A(char c) : data((int)c){
cout << "A(char)" << endl;
}
//A(const A& o) : data(o.data){
// cout << "A(const A&)" << endl;
//}
//形参是一个新变量,在调用时创建,由实参来初始化.
A(A o) : data(o.data){ //这样写是错误的,进入死循环
cout << "A(const A&)" << endl;
}
//创建对象时要调构造函数,调构造函数创建形参,形参又是一个新对象,
//创建新对象又要调构造函数,调构造函数又要创建形参,.......
void show() const{
cout << "data=" << data << endl;
}
virtual ~A(){
cout << "~A()" << endl;
// show(200);
// show(false);
// show('A');
//A a2(28);
//A a3(true);
//A a4('S');
//A a5(a2);
}
};
void show( A obj)
{
obj.show();
}
void func( const A& obj)
{
obj.show();
}
int main()
{
A a1;//调用无参构造函数
show(a1);
func(a1);
}
当类无构造函数时,会自动产生A(),A(const A&)构造函数.
+ 当类成员有指针成员指向动态内存时默认拷贝构造函数会出问题.
因为它会使两个指针指向同一个地方导致混乱.
这时我们需要重写这个拷贝构造函数.如下示例:
C++代码
#include <iostream>
using namespace std;
class A {
int data;
public :
A():data(5){ //初始化列表初始化的是成员而不是形参
cout << "A()" << endl;
}
//拷贝构造函数
A(const A& o)/* :data(o.data) */ {
cout << "A(const A&)" << endl;
}
void show(){
cout << "data=" << data << endl;
}
virtual ~A(){
cout << "~A()" << endl;
}
};
int main()
{
A a1;
a1.show(); //输出正常
A a2(a1);
a2.show(); //输出垃圾数据,所以初始化不能少
}
在类的成员函数中可以访问本类中任何成员变量.
自已定义拷贝构造函数之后,就没有默认的拷贝构造函数了,要在
自己定义的拷贝构造函数中处理所有需要处理的数据.
C++代码
//动态数组类,长度可动态变化.未完整版
#include <iostream>
using namespace std;
class Array {
char * p;
int len;
public :
Array(int n ) : len(n),p(NULL){
resize(n);
}
Array( const Array& o ) : len(o.len) {
p = new char[len];
for( int i=0; i<len; i++ )
p[i] = o.p[i];
}
void resize( int n ){
char * q = new char[n];
int min = (n<len?n:len);
if(p!=NULL){
for( int i=0; i<min; i++)
q[i] = p[i];
delete[] p;
}
p = q;
for( int i=min; i<n; i++)
p[i] = '/0';
len = n;
}
int size(){
return len;
}
void set( int index, char c ){
if( index<0 || index>len ){
cout << "Error" << endl;
return;
}
p[index] = c;
}
char get( int index ){
if( index<0 || index>len ){
cout << "Error" << endl;
return '^';
}
return p[index];
}
void fill ( char start, int skip ){
for( int i=0; i<len; i++)
p[i] = start + i*skip;
}
void show(){
for( int i=0; i<len; i++){
cout << p[i];
}
}
~Array(){
if(p!=NULL){
delete[ ] p;
p = NULL;
}
}
}; //end class Array
int main()
{
Array a1(10);
a1.fill('a',2);
a1.show();
cout << endl;
Array a2(a1);
a2.fill('A',2);
a2.show();
cout << endl;
a1.show();
cout << endl;
cout << "------------------" << endl;
cout << "Please input text(end by '$') : " << endl;
for(int i=0;;i++){
char c;
cin >> c;
if(c=='$')
break;
else if(i+1>a1.size()){
a1.resize(a1.size()+10);
}
a1.set(i,c);
}
a1.show();
cout << endl;
for( int i=0; i<a1.size(); i++){
cout << a1.get(i);
}
}
========================================
默认的拷贝构造函数是浅拷贝,自己写的拷贝构造函数是深拷贝.
* 运算符函数
* 单目运算符
C++代码
A operator+(A obj1,Aobj2){/* code */};
A a1(30),a2(50);
A result;
result = a1 + a2; //会去调A operator+(A obj1,Aobj2)
result.show();
C++代码
//示例
//由程序可知成员比友员要方便,少传一个参数
#include <iostream>
using namespace std;
class A{
//code
A sub( const A& o){
return A(data-o.data);
}
A oprator-()/......
};
A operator-(const A& o1, const A& o2){
//code...
}
int main()
{
A obj1(40),obj2(50);
A obj3,obj4;
obj3 = obj1.sub(obj2);
obj3.show();
obj4 = obj1 - obj2; //会去调obj1.aperator-(..)
}
运算符重载就是自已写运算符函数来规定运算符如何工作.
--------------------------
运算符函数的实现方法:
* 友元运算符函数:
- 在类中声明friend
- 定义:返回类型 operatorX(形参1,形参2)
- 调用: obj1 X obj2 解释成 operatorX(obj1,obj2),返回值作为运
算结果
* 成员函数: 直接在类中定义
- 定义: 返回类型 operatorX(形参1)
- 调用: obj1 X obj2 解释成 obj1.operator(obj2),返回值作为运算
结果
cout << f1 << f2;//用重载运算符表示,只能通过友员来实现
// 如果要用成员函数,则会有cout.operator<<(const F& f),所以这是不
// 可能的.因此只能用友员来实现,operator<<(cout,f)
// 而cout是ostream型的,因此有以下标准格式.注意不能加const,因为//
cout是要改变的,会改变里的缓冲成员.
ostream& operator<<( /* 不能加const */ ostream& cout, const
F&) //输出运算符的标准重载格式.
friend istream& operator>>(istream& is, F& f){
}//输入运算符重载标准格式
C++代码
//重载运算符完整例子
//双目运算符重载
#include <iostream>
using namespace std;
class F{
int n;
int d;
public :
F(int n=0, int d=1):n(n),d(d){}
friend ostream& operator<<(ostream& os, const F& f){
os << '[' << f.n << '/' << f.d <<']';
return os;
}
F operator*(const F& o) {
return F(n*o.n,d*o.d);
}
friend F operator/(const F& f1,const F& f2){
return F(f1.n*f2.d,f1.d*f2.n);
}
friend istream& operator>>(istream& is, F& f){
char ch;
is >> f.n >> ch >> f.d;
return is;
}
};
int main()
{
F f1(3,5),f2(11,7),f;
cout << f1 << '*' << f2 << '=' << f1*f2 << endl;
cout << f1 << '/' << f2 << '=' << f1/f2 << endl;
cout << "Input 2 fractions :";
cin >> f1 >> f2;
cout <<"f1=" << f1 << endl;
cout << "f2=" << f2 << endl;
}
* 单目运算符重载
-友元函数形式,返回类型 operatorX(形参)
使用:X obj ---> operatorX(obj);
-成员函数形式 尽量用成员 返回类型 operatorX(/*无形参*/)
使用: X obj ---> obj.operator();
c++代码
//单目运算符重载
//把后++,后--当作双目运算符,第二个操作数是整形.
#include <iostream>
using namespace std;
class A{
int data;
public :
A(int d=0):data(d){}
friend ostream& operator<<(ostream& os,const A& a){
os << a.data;
return os;
}
friend istream& operator>>(istream& is,A& a){
is >> a.data;
return is;
}
friend A& operator++(A& a){
a.data += 10;
return a;
}
A& operator--(){
data -= 10;
return *this;
}
//后加加,规定一个整形为形参,与先加加区分
friend A/* 此时不再用引用 */ operator++(A& a,int){
A old(a);
a.data += 1;
return old;
}
//后减减,规定为一个整形为形参,与先减减区分.
A /*不要引用*/ operator--(int){
A old(*this);
data -= 1;
return old;
}
};
int main()
{
A a1(50),a2(100);
cout << "a1=" <<a1 << endl;
cout << "a2=" <<a2 << endl;
cout << "++a1=" << ++a1 << endl;
cout << "--a1=" << --a1 << endl;
cout << "a1++=" << a1++ << endl;
cout << "a1=" <<a1 << endl;
cout << "a2--=" << a2-- << endl;
cout << "a2=" <<a2 << endl;
}
运算符重载提供了一个自己规定运算符式作方式的方法,至少有一个操
作数是自定义类型的.基本类型我们是规定不了的.
强制类型转换:类型(数据) --> (不必写返回类型,因为始终与后面的类
型是相同的) operator类型(无形参) 只能写成成员函数,不能是友员.
C++代码
#include<iostream>
using namespace std;
class A{
int data;
public:
A(int d=0):data(d){}
operator int(){
return data;
}
operator bool(){
return data!=0;
}
operator char(){
return (char)data;
}
};
int main()
{
A a1(65),a2(200);
cout << "a1=" << (char)a1 << endl;
int d=a2;
if(a2)
cout << "good" << endl;
}
对自定义类型的对象,使用运算符时,总是调用相应的运算符函数
三目运算符不能重载.
等号是双目运算符也可重载,它也只能是成员.
还有点号('.')不能重载.
双冒号(::)不能重载.
sizeof(类型)没法重载.
#号不是运算符,无所谓重载.
'= () [] -> 类型转换'只能是成员函数来重载,其它的随便,我们建议尽量
使用成员函数来写,有点只能用友元,比如输入输出.
==================================================
+ 双目运算符重载
- 友元形式:返 operator符号(形1,形2)
- 成员形式:返 operator符号(形)
+ 单目运算符重载
- 友元: 返 operator符号(形参)
- 成员: 返 operator符号()
+ 特例
- 加加
- 先加加
- 后加加 返回 operator符号(形,int)
- 减减
- 先减减
- 后减减
- 类型转换 只能是成员perator 空格 类型();
扫一扫
8282
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
