C++(30)构造函数和复制控制
2015-08-08 20:00
381 查看
面向对象编程
--转换与继承、复制控制与继承
I.转换与继承
引言:由于每个派生类对象都包含一个基类部分,因此可以像使用基类对象一样在派生类对象上执行操作。
对于指针/引用,可以将派生类对象的指针/引用转换为基类子对象的指针/引用。
基类类型对象既可以作为独立对象存在,也可以作为派生类对象的一部分而存在,因此,一个基类对象可能是也可能不是一个派生类对象的部分,因此,没有从基类引用(或基类指针)到派生类引用(或派生类指针)的(自动)转换。
关于对象类型,虽然一般可以使用派生类型的对象对基类类型的对象进行初始化或赋值,但,没有从派生类型对象到基类类型对象的直接转换。
一、派生类到基类的转换
如果有一个派生类型的对象,则可以使用它的地址对基类类型的指针进行赋值或初始化。同样,可以使用派生类型的引用或对象初始化基类类型的引用。但是,对象没有类似转换。编译器不会自动将派生类型对象转换为基类类型对象。
但是,一般可以使用派生类型对象对基类对象进行赋值或初始化。对对象进行初始化和/或赋值以及可以自动转换引用或指针。
1、引用转换不同于转换对象
关于引用转换:将对象传给希望接受引用的函数时,引用直接绑定到该对象,虽然看起来在传递对象,实际上实参是该对象的引用,对象本身未被复制,并且,转换不会在任何方面改变派生类型对象,该对象仍是派生类型对象。
关于对象转换:将派生类对象传给希望接受基类类型对象(而不是引用)的函数时,形参的类型是固定的——在编译时和运行时形参都是基类类型对象。如果用派生类型对象调用这样的函数,则该派生类对象的基类部分被复制到形参。
小结:一个是派生类对象转换为基类类型引用,一个是用派生类对象对基类对象进行初始化或赋值。
2、用派生类对象对基类对象进行初始化或赋值
对基类对象进行初始化或赋值,实际上是在调用函数:初始化时调用构造函数,赋值时调用赋值操作符。
基类一般(显式或隐式地)定义自己的复制构造函数和赋值操作符,这些成员接受一个形参,该形参是基类类型的(const)引用。因为存在从派生类引用到基类引用的转换,这些复制控制成员可用于从派生类对象对基类对象进行初始化或赋值:
[cpp] view
plaincopy
Item_base item;
Bulk_item bulk;
Item_base item1(bulk); //调用Item_base的复制构造函数
item = bulk; //调用Item_base的赋值操作符
用Bulk_item类型的对象调用Item_base类的复制构造函数或赋值操作符时,将发生下列步骤:
1)将Bulk_item对象转换为Item_base引用,这仅仅意味着将一个Item_base引用绑定到Bulk_item对象。
2)将该引用作为实参传给复制构造函数或赋值操作符。
3)那些操作符使用Bulk_item的 Item_base部分分别对调用构造函数或赋值的 Item_base对象的成员进行初始化或赋值。
4)一旦操作符执行完毕,对象即为Item_base。它包含Bulk_item的 Item_base部分的副本,但实参的Bulk_item部分被忽略。
在这种情况下,bulk的Bulk_item部分在对item进行初始化或赋值时被“切掉”了。Item_base对象只包含基类中定义的成员,不包含由任意派生类型定义的成员,Item_base对象中没有派生类成员的存储空间。
3、派生类到基类转换的可访问性
像继承的成员函数一样,从派生类到基类的转换可能也可能不是可访问的。转换是否可以访问取决于在派生类的派生列表中指定的访问标号。
【提示:】要确定到基类的转换是否可访问,可以考虑基类的public成员是否可访问,如果可以,则转换是可访问的,否则,转换是不可访问的!
1)public继承:用户代码和后代类都可以使用派生类到基类的转换。
2)private或 protected继承:则用户代码不能将派生类型对象转换为基类对象。如果是 private继承,则从private继承类派生的类不能转换为基类。如果是protected继承,则后续派生类的成员可以转换为基类类型。
无论是什么派生访问标号,派生类本身都可以访问基类的public[protected]成员,因此,派生类本身的成员和友元总是可以访问派生类到基类的转换。
二、基类到派生类的转换
从基类到派生类的自动转换是不存在的:
[cpp] view
plaincopy
Item_base base;
Bulk_item *bulkP = &base; //Error
Bulk_item &bulkRef = base; //Error
Bulk_item bulk = base; //Error
没有从基类类型到派生类型的(自动)转换,原因在于基类对象只能是基类对象,它不能包含派生类对象的成员。如果允许基类对象给派生类类型对象赋值,那么就可以试图使用派生类对象访问不存在的成员!
更有甚者:当基类指针或引用实际绑定到派生类对象时,从基类到派生类的转换也存在限制:
[cpp] view
plaincopy
Bulk_item bulk;
Item_base *itemP = &bulk;
Bulk_item *bulkP = itemP; //Error
编译器在编译时无法知道特定转换在运行时实际上是安全的。编译器确定转换是否合法,只看指针或引用的静态类型。
在这些情况下,如果用户知道从基类到派生类的转换是安全的,就可以使用static_cast强制编译器进行转换。或者,可以用dynamic_cast申请在运行时进行检查。
[cpp] view
plaincopy
Bulk_item bulk;
Item_base *itemP = &bulk;
Bulk_item *bulkP = static_cast<Bulk_item*>(itemP); //OK
Bulk_item *bulkP = dynamic_cast<Bulk_item*>(itemP); //OK
II.复制控制与继承
引言:当构造、复制、赋值和撤销派生类对象时,也会构造、复制、赋值和撤销基类子对象!
构造函数和复制控制成员不能继承,每个类定义自己的构造函数和复制控制成员。像任何类一样,如果类不定义自己的默认构造函数和复制控制成员,则编译器将使用合成版本!
一、基类构造函数和复制控制
本身不是派生类的基类,其构造函数和复制控制基本上不受继承影响:
[cpp] view
plaincopy
Item_base(const std::string &book = "",
double sales_price = 0.0):
isbn(book),price(sales_price) {}
构造函数可以设置成为protected或private,某些类需要只希望派生类使用的特殊构造函数,则将够函数设置成为protected。
二、派生类构造函数
每个派生类构造函数出了初始化自己的数据成员,还要初始化基类!
1、合成的派生类默认构造函数
派生类的合成默认构造函数与非派生类的构造函数只有一点不同:除了初始化派生类的数据成员之外,它还需要初始化派生类对象的基类部分[其实是先初始化基类部分的,一定要掌握好初始化顺序]!
对于Bulk_item类,合成的默认构造函数执行顺序:
1)调用Item_base的默认构造函数;[基类]
2)用常规变量初始化规则初始化Bulk_item的成员,也就是说,qty和discount成员是未初始化的![派生类]
2、定义默认构造函数
因为Bulk_item具有内置类型成员,所以应定义自己的默认构造函数:
[cpp] view
plaincopy
class Bulk_item:public Item_base
{
public:
Bulk_item():min_qty(0),discount(0) {}
// AS Before...
};
该构造函数出了初始化qty和discount成员之外,还会隐式调用Item_base的默认构造函数初始化对象的基类部分[其实是先运行基类的默认构造函数的!]。
运行这个构造函数的效果是,首先使用Item_base的默认构造函数初始化Item_base部分,Item_base的构造函数执行完毕后,再初始化Bulk_item部分的成员并执行构造函数的函数体(函数体为空)。
3、向基类构造函数传递实参
派生类构造函数初始化列表只能初始化派生类的成员,不能直接初始化继承成员。相反,派生类构造函数通过将基类构造函数包含在初始化列表中来间接初始化继承成员:
[cpp] view
plaincopy
Bulk_item(const std::string &book,double sales_price,
std::size_t qty = 0,double disc_rate = 0):
Item_base(book,sales_price),
min_qty(qty),discount(disc_rate) {}
这个构造函数可以这样使用:
[cpp] view
plaincopy
Bulk_item bulk("0-201-82470-1",50,5,.19);
要建立bulk:
1)首先运行Item_base构造函数,该构造函数使用Bulk_item构造函数初始化列表来传递来的实参初始化isbn和price。
2)初始化Bulk_item的成员。
3)运行Bulk_item的构造函数(空)函数体。
【小结】
构造函数初始化列表为类的基类和成员提供初始值,它并不指定初始化的执行次序。首先初始化基类,然后根据声明次序初始化派生类的成员。
4、在派生类构造函数中使用默认实参
可以将这两个Bulk_item构造函数编写为一个接受默认实参的构造函数:
[cpp] view
plaincopy
class Bulk_item:public Item_base
{
public:
Bulk_item(const std::string &book = "",double sales_price = 0.0,
std::size_t qty = 0,double disc_rate = 0):
Item_base(book,sales_price),
min_qty(qty),discount(disc_rate) {}
//AS Before
};
5、只能初始化直接基类
一个派生类类只能初始化它自己的直接基类,直接基类就是在派生列表中指定的类。
可以设置一个折扣策略需要一个数量和一个折扣量,可以定义名为Disc_item的新类存储数量和折扣量,以支持这些根据购买量来打折的折扣策略。Disc_item类可以不定义net_price函数,但可以作为定义不同折扣策略的其他类(如Bulk_item类)的基类。
【关键概念:重构】
将Disc_item加到Item_base层次是重构的一个例子。重构包括重新定义类层次,将操作和/或数据从一个类移到另一个类。为了适应应用程序的需要而重新设计类以便增加新的函数或处理其他改变时,最有可能需要进行重构。
重构在面向对象应用程序中非常常见。值得注意的是:虽然改变了继承层次,使用Bulk_item或Item_base类的代码不需要改变。然而,对类进行重构,或以任意其他方式改变类,使用这些类的任意代码都必须重新编译。
要实现这个设计:
1)首先需要定义Disc_item类:
[cpp] view
plaincopy
class Disc_item : public Item_base
{
public:
Disc_item(const std::string &book = "",
double sales_price = 0.0,
std::size_t qty = 0,
double disc_rate = 0.0):
Item_base(book,sales_price),quantity(qty),discount(disc_rate) {}
protected:
std::size_t quantity;
double discount;
};
2)其次,可以重新实现Bulk_item以继承Disc_item,而不再是直接继承Item_base:
[cpp] view
plaincopy
class Bulk_item : public Disc_item
{
public:
Bulk_item(const std::string &book = "",
double sales_price = 0.0,
std::size_t qty = 0,
double disc_rate = 0.0):
Disc_item(book,sales_price,qty,disc_rate) {}
//重定义根类的Item_base::net_price
double net_price(std::size_t ) const;
};
现在,每个Bulk_item对象有三个子对象:一个(空的)Bulk_item部分、一个Disc_item子对象,Disc_item子对象又有一个Item_base基类子对象。
由于派生类构造函数只能初始化自己的直接基类,因此在Bulk_item类的构造函数初始化列表中指定Item_base是一个错误。
【关键概念:尊重基类接口】
构造函数只能初始化其直接基类的原因是每个类都定义了自己的接口。定义Disc_item时,通过定义它的构造函数指定了怎样初始化Disc_item对象。一旦类定义了自己的接口,与该类对象的所有交互都应该通过该接口,即使对象是派生类对象的一部分也不例外。
同样,派生类构造函数不能初始化基类的成员且不应该对基类成员赋值。如果那些成员为 public或protected,派生构造函数可以在构造函数函数体中给基类成员赋值,但是,这样做会违反基类的接口。派生类应通过使用基类构造函数尊重基类的初始化意图,而不是在派生类构造函数函数体中对这些成员赋值。
[cpp] view
plaincopy
//P493 习题15.14
class Item_base
{
public:
Item_base(const std::string &book = "",
double sales_price = 0.0):
isbn(book),price(sales_price) {}
private:
std::string isbn;
double price;
};
class Bulk_item : public Item_base
{
public:
Bulk_item(const std::string &book = "",
double sales_price = 0.0,
std::size_t qty = 0,
double disc_rate = 0.0):
Item_base(book,sales_price),
min_qty(qty),discount(disc_rate) {}
private:
std::size_t min_qty;
double discount;
};
[cpp] view
plaincopy
//习题15.16
//1)
struct C1 : public Base
{
C1(int val):Base(val) {}
};
[cpp] view
plaincopy
//2)
struct C2 : public C1
{
C2(int val):C1(val) {}
};
[cpp] view
plaincopy
//3)
struct C3 : public C1
{
C3(int val):C1(val) {}
};
[cpp] view
plaincopy
//4)
struct C4 : public Base
{
C4(int val):Base(val) {};
};
[cpp] view
plaincopy
//5)
struct C5 : public Base
{
C5(int ival):Base(ival) {}
};
面向对象编程
--构造函数和复制控制[续]
三、复制控制和继承合成操作对对象的基类部分连同派生类部分的成员一起进行复制、赋值或撤销,使用基类的复制构造函数、赋值操作符或析构函数对基类部分进行复制、赋值或撤销。
类是否需要定义复制控制成员完全取决于类自身的直接成员。基类可以定义自己的复制控制而派生类使用合成版本,反之,基类使用合成版本,而派生类使用自己定义的复制控制也可以。
只包含类类型或内置类型的数据成员、不包含指针的类一般可以使用合成操作,复制、赋值或撤销这样的成员不需要使用特殊控制。但是:具有指针成员的类一般要定义自己的复制控制来管理这些成员!
先复制基类部分,然后复制派生类部分。
1、定义派生类复制构造函数
如果派生类显式定义自己的复制构造函数或赋值操作符,则该定义将完全覆盖默认定义。被继承类的复制构造函数和赋值操作符负责对基类成分以及类自己的成员进行复制或赋值。
如果派生类定义了自己的复制构造函数,则该复制构造函数一般应显式使用基类复制构造函数初始化对象的基类部分:
[cpp] view
plaincopy
class Base
{
public:
//...
};
class Derived : public Base
{
public:
Derived(const Derived &d):Base(d)
{
//...
}
};
初始化函数Base(d)将派生类对象d转换为它的基类部分的引用,并调用基类复制构造函数。
如果省略基类初始化函数:
[cpp] view
plaincopy
Derived(const Derived &d)
{
//...
}
则运行Base的默认构造函数初始化对象的基类部分。假定Derived成员的初始化从d复制对应成员,则新构造的对象将具有奇怪的配置:它的Base部分将保存默认值,而它的Derived成员是另一对象的副本。
2、派生类赋值操作符
如果派生类定义了自己的赋值操作符,则该操作符必须对基类部分进行显式赋值!
[cpp] view
plaincopy
//Base::operator=(const Base &) 不会自动被调用,只有显式调用它!
Derived &operator=(const Derived &rhs)
{
//赋值操作符必须防止自身赋值
if (this != &rhs)
{
/*
*基类的赋值操作符可以由类定义,也可以是合成赋值操作符
*/
Base::operator=(rhs);
//定义自己的派生类赋值操作符部分
//...
}
return *this;
}
3、派生类析构函数
析构函数的工作与复制构造函数和赋值操作符不同:派生类析构函数不负责撤销基类对象的成员。编译器总是显式调用派生类对象基类部分的析构函数。每个析构函数只负责清除自己的成员:
[cpp] view
plaincopy
//自动调用Base::~Base()
~Derived()
{
//...
}
对象的撤销顺序与构造顺序相反:首先运行派生类析构函数,然后按继承层次依次向上调用各基类析构函数!
构造函数&赋值操作符&复制构造与 析构函数的对比 | |
---|---|
构造函数&赋值操作符&复制构造函数 | 析构函数 |
1、既要负责自己的成员,又要负责基类[调用基类相应定义] | 只需负责自己的成员就好了 |
2、首先运行基类的构造|复制|赋值,然后运行派生类的 | 首先运行派生类的,然后调用基类的 |
3、不能定义为虚函数 | 可以定义为虚函数[而且一般是虚函数] |
删除指向动态分配对象的指针时,需要运行析构函数在释放对象的内存之前清除对象。处理继承层次中的对象时,指针的静态类型可能与被删除对象的动态类型不同,可能会删除实际指向派生类对象的基类类型指针。
如果删除基类指针,则需要运行基类析构函数并清除基类的成员,如果对象实际是派生类型的,则没有定义该行为。要保证运行适当的析构函数,基类中的析构函数必须为虚函数:
[cpp] view
plaincopy
class Item_base
{
public:
virtual ~Item_base() {}
//...
};
如果析构函数为虚函数,那么通过指针调用时,运行哪个析构函数将因指针所指向对象的类型的不同而不同!
[cpp] view
plaincopy
Item_base *itemP = new Item_base;
delete itemP; //调用Item_base版本
itemP = new Bulk_item; //此时就是指针的静态类型与动态类型不同
delete itemP; //调用Bulk_item版本
如果层次中根类的析构函数为虚函数,则派生类析构函数也将是虚函数,无论派生类显式定义析构函数还是使用合成析构函数,派生类析构函数都是虚函数。
“三法则”指出:如果类需要析构函数,则类几乎也确实需要其他复制控制成员。基类几乎总是需要析构函数,从而可以将析构函数设为虚函数。如果基类为了将析构函数设为虚函数则具有空析构函数,那么,类具有析构函数并不表示也需要赋值操作符或复制构造函数。
【最佳实践】
即使析构函数没有工作要做,继承层次的根类也应该定义一个虚析构函数。
构造函数和赋值操作符不是虚函数
在复制控制成员中,只有析构函数应定义为虚函数,构造函数不能定义为虚函数。构造函数是在对象完全构造之前运行的,在构造函数运行时,对象的动态类型还不完整!
将类的赋值操作符设为虚函数很可能会令人混淆,而且不会有什么好处!
[cpp] view
plaincopy
//P496 习题15.18 说明在什么情况下该具有虚析构函数?
/*
*作为基类使用的类应该具有虚析构函数:
*以保证在删除(指向动态分配对象的)基类指针时,
*根据指针实际指向的对象所属的类型运行适当的析构函数!
*如:
*/
Item_base *itemP = new Bulk_item;
delete itemP; //需要运行的是Bulk_item的析构函数
[cpp] view
plaincopy
//习题15.20
class Item_base
{
public:
Item_base(const std::string &book = "",
double sales_price = 0.0):
isbn(book),price(sales_price)
{
cout <<
"Item_base(const std::string &,double)"
<< endl;
}
Item_base(const Item_base &rhs);
Item_base &operator=(const Item_base &rhs);
virtual ~Item_base();
private:
std::string isbn;
protected:
double price;
};
Item_base::Item_base(const Item_base &rhs):isbn(rhs.isbn),price(rhs.price)
{
cout << "Item_base(const Item_base &)" << endl;
}
Item_base &Item_base::operator=(const Item_base &rhs)
{
isbn = rhs.isbn;
price = rhs.price;
cout << "operator=(const Item_base &)" << endl;
return *this;
}
Item_base::~Item_base()
{
cout << "~Item_base()" << endl;
}
class Bulk_item : public Item_base
{
public:
Bulk_item(const std::string &book = "",
double sales_price = 0.0,
std::size_t qty = 0,
double disc_rate = 0.0):
Item_base(book,sales_price),
min_qty(qty),discount(disc_rate)
{
cout <<
"Bulk_item(const std::string &book,double,std::size_t,double)"
<< endl;
}
Bulk_item(const Bulk_item &rhs);
Bulk_item &operator=(const Bulk_item &rhs);
~Bulk_item();
private:
std::size_t min_qty;
double discount;
};
Bulk_item::Bulk_item(const Bulk_item &rhs):
Item_base(rhs),min_qty(rhs.min_qty),discount(rhs.discount)
{
cout << "Bulk_item(const Bulk_item &)" << endl;
}
Bulk_item &Bulk_item::operator=(const Bulk_item &rhs)
{
if (this != &rhs)
{
Item_base::operator=(rhs);
min_qty = rhs.min_qty;
discount = rhs.discount;
}
cout << "operator=(const Bulk_item &)" << endl;
return *this;
}
Bulk_item::~Bulk_item()
{
cout << "~Bulk_item()" << endl;
}
int main()
{
Item_base *itemP = new Bulk_item;
delete itemP;
Item_base base;
Bulk_item bulk;
base = bulk;
Item_base text(bulk);
}
五、构造函数和析构函数中的虚函数
构造派生类对象时首先运行基类构造函数初始化对象的基类部分。在执行基类构造函数时,对象的派生类部分是未初始化的。实际上,此时对象还不是一个派生类对象。
撤销派生类对象时,首先撤销它的派生类部分,然后按照与构造顺序的逆序撤销它的基类部分。
在这两种情况下,运行构造函数或析构函数时候,对象都是不完整的。为了适应这种不完整,编译器将对象的类型视为在构造函数或析构期间发生了变化。在基类构造函数或析构函数中,将派生类对象当做基类类型对象对待!
如果在构造函数或析构函数中调用虚函数,则运行的是为构造函数或析构函数自身类型定义的版本!
[cpp] view
plaincopy
class Item_base
{
public:
Item_base(const std::string &book = "",
double sales_price = 0.0):
isbn(book),price(sales_price)
{
display();
}
virtual ~Item_base()
{
display();
}
virtual void display()
{
cout << "in Item_base!" << endl;
}
private:
std::string isbn;
double price;
};
class Bulk_item : public Item_base
{
public:
Bulk_item(const std::string &book = "",
double sales_price = 0.0,
std::size_t qty = 0,
double disc_rate = 0.0):
Item_base(book,sales_price),
min_qty(qty),discount(disc_rate)
{
display();
}
void display()
{
cout << "in Bulk_item!" << endl;
}
~Bulk_item()
{
display();
}
private:
std::size_t min_qty;
double discount;
};
无论由构造函数(或析构函数)直接调用虚函数,或者从构造函数(或析构函数)所调用的函数间接调用虚函数,都应用这种绑定。
[理解]如果从基类构造函数(或析构函数)调用虚函数的派生类版本会怎么样?
虚函数的派生类版本很可能会访问派生类对象的成员,毕竟,如果派生类版本不需要使用派生类对象的成员,派生类多半能够使用基类中的定义。但是,对象的派生部分的成员不会在基类构造函数运行期间初始化,实际上,如果允许这样的访问,程序很可能会崩溃。
相关文章推荐
- C++(29)基类和派生类
- C++(28)自增/自减操作符
- C++(27)输入/输出、算术/关系操作符
- C++(26)重载操作符的定义
- C++(25)管理指针成员
- C++(24)消息处理示例
- C语言文件读写操作
- C++对象模型——Member的各种调用方式(第四章)
- C++(23)析构函数
- C++(22)复制构造函数
- C++(21)友元、static成员
- C++(20)构造函数
- CVTE内推面试(c++)
- C++(19)类与数据抽象
- c++中的重载
- 关于C语言中的存储区划分以及相关内容
- c/c++下 long long与__int64不同编译环境的比较
- 【C++】智能指针的实现
- C/C++ 数据范围(int ,char long, float,double)
- 【C++基金会 04】vector详细解释