C++博客-jlz-文章分类-c++ primer plus 读书笔记

第13章类继承 (13.4 抽象基类)

jz — Thu, 25 Sep 2008 03:24:00 GMT

抽象基类(abstract base class ,ABC)
C++通过纯虚函数(pure virtual function)提供未实现的函数.纯虚函数声明的结尾为 = 0 .
class BaseEllipse //abstract base class
{
private:
double x;
double y;
public:
BaseEllipse(double x0 = 0 , double y0 = 0):x(x0),y(yo){}
virtual ~BaseEllipse(){}
void Move(int nx,ny) { x = nx; y = ny;}
virtual double Area() const = 0; // a pure virtual funtion
}

当类声明中包含纯虚函数时，则不能创建该类的对象，只能做为基类。要成为真正
ABC，必须包含一个纯虚函数。

jz 2008-09-25 11:24 发表评论

第13章类继承 (13.4 单设计模式)

jz — Wed, 24 Sep 2008 15:17:00 GMT

希望有且只有一个类的实列返回给调用程序时，就可以使用单元素模式(singleton pattern):

class TheOnlyInstance
{
public:
static TheOnlyInstance * GetTheOnlyInstance();

protected:
TheOnlyInstance(){}
};

通过把构造函数声明为protected,并去掉公有构造。防止局部实例被创建。

TheOnlyInstance the; // not allowed

只能通过公有静态方法GetTheOnlyInstance 来访问类。
通过把构造函数声明为protected,并去掉公有构造。防止局部实例被创建。

TheOnlyInstance * TheOnlyInstance ： GetTheOnlyInstance()
{
static TheOnlyInstance obj;
return &obj;
}

检索指向这个类的指针，只需要调用GetTheOnlyInstance()

TheOnlyInstance* pTheOnlyInstance = TheOnlyInstance: GetTheOnlyInstance();

jz 2008-09-24 23:17 发表评论

第13章类继承 (13.4 有关虚函数注意事情)

jz — Wed, 24 Sep 2008 13:51:00 GMT

重新定义隐藏方法:

class Dwelling
{
public:
virtual void showperks(int a) const;
};

class Hovel: public Dwelling
{
public:
virtual void showperks() const;
};

Hovel trump;
trump.showperks(); //valid
trump.showperks(5); //invalid

1.如果重新定义继承的方法，要保持原型相同。但如果返回类型是基类引用或指针，则可以修改为指向派生类的引用或指针，这种特性称为返回类型协变.

class Dwelling
{
public:
virtual Dewlling & build(int n);
};

class Hovel : public Dwelling
{
public:
virtual Hovel &build(int n);
};

2. 如果基类声明被重载了，则在派生类中应该重定义所有的基类版本。否则其他版本将被隐藏。

class Dwelling
{
virtual void showperks(int a) const;
virtual void showperks(double x) const;
virtula void showperks() const;
};
class Hovel: public Dwelling
{
virtual void showperks(int a) const;
virtual void showperks(double x) const;
virtula void showperks() const;
};

jz 2008-09-24 21:51 发表评论

第13章类继承 (13.4 指针和引用类型兼容性)

jz — Sun, 21 Sep 2008 15:47:00 GMT

class Employee
{
private:
char name[40];
public:
void showname();
};

class Singer : public Employee
{
public:
void range();
};

Employee e;
Singer s;

Employee *pe = &s; //允许向上隐式类型转换
Singer *ps = (Singer*) &e; //必须向下显式类型转换

pe->showname() //安全因singer 是Employee(每个singer都继承姓名).

ps->range() ; //不安全，因Employee 并不是singer .

jz 2008-09-21 23:47 发表评论

第13章类继承 (13.4 为何需要虚构函数)

jz — Sun, 21 Sep 2008 15:38:00 GMT

     使用虚构函数可以确保正确的析构函数顺序被调用。
    virtual ~Brass();

   如果BrassPlus 包含一个执行某些操作的析构函数，则Brass必须有一个虚拟析构函数，即使该析构函数不执行任何操作。

jz 2008-09-21 23:38 发表评论

第13章类继承 (13.4 虚方法实现)

jz — Sun, 21 Sep 2008 15:33:00 GMT

#include
#include
using std::cout;
using std::ios_base;
using std::endl;
using std::cin;

#ifndef BRASS_H_
#define BRASS_H_
class Brass
{
private:
enum {MAX = 35};
char fullname[MAX];
long accNum;
double balance;
public:
Brass(const char* s="Nullbody",long an = -1, double bal=0.0);
void Deposit(double amt);
virtual void WithDraw(double amt);
double Balance() const;
virtual void ViewAcct() const;
virtual ~Brass(){}
};

class BrassPlus :public Brass
{
private:
double maxLoan;
double rate;
double owesBank;
public:
BrassPlus(const char* s="Nullbody", long an=-1,double bal = 0.0,double ml = 500,double r=0.10);
BrassPlus(const Brass &ba, double ml = 500 ,double r= 0.1);
virtual void ViewAcct() const;
virtual void WithDraw(double amt);
void ResetMax(double m) { maxLoan = m;}
void ResetRate(double r) { rate = r;}
void ResetOwes() { owesBank = 0;}

};

#endif

Brass::Brass(const char* s,long an, double bal)
{
std::strncpy(fullname,s,MAX-1);
fullname[MAX-1] = '\0';
accNum = an;
balance = bal;
}

void Brass::Deposit(double amt)
{
if(amt < 0 )
  cout<<"Negative desposit not allowed:"
   <<"desposit is cancelled.\n";
else
  balance +=amt;
}

void Brass::WithDraw(double amt)
{
  if(amt < 0 )
  cout<<"Negative desposit not allowed:"
   <<"desposit is cancelled.\n";
  else if(amt <=balance)
   balance -= amt;
  else
   cout<<"withdrawal amount of $"<   <<"exceeds your balance.\n"
   <<"withdrawal canceled.\n";

}

double Brass::Balance() const
{
return balance;
}

// 非构造函数不能使用成员初始化列表，但派生类方法可以调用公有的基类方法
void Brass::ViewAcct() const
{
//set up ###.## format
ios_base::fmtflags initialState = cout.setf(ios_base::fixed,ios_base::floatfield);
cout.setf(ios_base::showpoint);
cout.precision(2);
cout<<"Client:"< cout<<"Account Numver:"< cout<<"Balance:$"<

cout.setf(initialState);

}

BrassPlus::BrassPlus(const char* s,long an ,double bal,double ml ,double r):Brass(s,an,bal)
{
maxLoan =ml;
owesBank = 0.0;
rate = r;
}

BrassPlus::BrassPlus(const Brass &ba,double ml,double r):Brass(ba)
{
maxLoan = ml;
owesBank = 0.0;
rate = r;
}

void BrassPlus::ViewAcct() const
{
ios_base::fmtflags initialState = cout.setf(ios_base::fixed,ios_base::floatfield);
cout.setf(ios_base::showpoint);
Brass::ViewAcct(); //dispaly base portion
cout<<"Maxinum loam:$"< cout<<"Owed to Bank:$"< cout<<"Loan Rate:"<<100 * rate <<"%\n";
cout.setf(initialState);

}
void BrassPlus::WithDraw(double amt)
{
//set up ###.## format
ios_base::fmtflags initialState = cout.setf(ios_base::fixed,ios_base::floatfield);
cout.setf(ios_base::showpoint);
cout.precision(2);
double bal = Balance();
if(amt <=bal)
  Brass::WithDraw(amt); // 代码必须使用作用域解析操作符
else if(amt <= bal + maxLoan - owesBank)
{
  double advance = amt - bal;
  owesBank += advance *(1.0 + rate);
  cout<<"Bank advance:$"<  cout<<"Finance charge:$"<  Deposit(advance);
  Brass::WithDraw(amt);

}
else
{
cout<<"Credit limit exceeded. transaction cancelled.\n";

}
cout.setf(initialState);

}

//创建指向Brass 对象的指针数组，这样可以指向Brass也可以指向BrassPlus
// 使用一个数组来表示多种类型的对象，这就是多态

const int CLIENTS = 4;
const int LEN = 40;
int main()
{
Brass *p_client[CLIENTS];
int i;

for(i=0; i {
   char temp[LEN];
    long tempnum;
    double tempbal;
    char kind;
    cout<<"Enter client's name:";
    cin.getline(temp, LEN);

cout<<"enter client's account number:";
cin>>tempnum;

cout<<"enter opening balance :$";
cin>>tempbal;

cout<<" enter 1 for blass account or "
<<" 2 for brassplus account:";

    while(cin>>kind &&(kind != '1' && kind !='2'))
     cout<<"enter either 1 or 2:";
    if(kind == '1')
     p_client[i] = new Brass(temp,tempnum,tempbal);
    else
    {
     double tmax, trate;
     cout<<"enter the owerdraft limit:$";
     cin >> tmax;
     cout<<"enter the interest rate "
      <<"as a decimal fraction:";
     cin >> trate;

p_client[i] = new BrassPlus(temp,tempnum,tempbal,tmax,trate);

}

while(cin.get() !='\n')
continue;

}

cout< for( i= 0 ;i {
p_client[i]->ViewAcct();
cout< }

for(i=0;i {
delete p_client[i];

}

cout<<"done.\n";
return 0;

}

jz 2008-09-21 23:33 发表评论

第13章类继承 (13.4 银行类实现)

jz — Sun, 21 Sep 2008 15:17:00 GMT

#include
#include
using std::cout;
using std::ios_base;
using std::endl;

};

#endif

Brass::Brass(const char* s,long an, double bal)
{
std::strncpy(fullname,s,MAX-1);
fullname[MAX-1] = '\0';
accNum = an;
balance = bal;
}

void Brass::Deposit(double amt)
{
if(amt < 0 )
  cout<<"Negative desposit not allowed:"
   <<"desposit is cancelled.\n";
else
  balance +=amt;
}

}

double Brass::Balance() const
{
return balance;
}

cout.setf(initialState);

}

BrassPlus::BrassPlus(const char* s,long an ,double bal,double ml ,double r):Brass(s,an,bal)
{
maxLoan =ml;
owesBank = 0.0;
rate = r;
}

BrassPlus::BrassPlus(const Brass &ba,double ml,double r):Brass(ba)
{
maxLoan = ml;
owesBank = 0.0;
rate = r;
}

}
else
{
cout<<"Credit limit exceeded. transaction cancelled.\n";

}
cout.setf(initialState);

}

int main()
{
Brass piggy("porcelot pigg",3222233,111.00);
BrassPlus hoggy("hogg",3222333,3000.00);

piggy.ViewAcct();
cout<

hoggy.ViewAcct();
cout<

cout<<"Depositing $1000 into the hoggy accout:\n";
hoggy.Deposit(1000.00);
cout<<"new balance :$"<

cout<<"WithDrawing $4200 from the pigg account:\n";

piggy.WithDraw(4200.00);
cout<<"pigg account balance :$"< cout<<"with drawing $4200 from the hogg account.\n";
hoggy.WithDraw(4200.00);
hoggy.ViewAcct();
return 0;
}

jz 2008-09-21 23:17 发表评论

第13章类继承 (13.4 多态公有继乘)

jz — Sun, 21 Sep 2008 08:39:00 GMT

多态: 同一方法的行为将随上下文而不同。实现方法:
1. 在派生类中重定义基类方法
2.使用虚方法

#ifndef BRASS_H_
#define BRASS_H_
class Brass
{
private:
enum {MAX = 35};
char fullname[MAX];
long accNum;
double balance;
public:
Brass(const char* s="Nullbody",long an = -1, double bal=0.0);
void Deposit(double amt);
virtual void WithDraw(double amt);
double Balance() const;
virtual void ViewAcct() const;
virtual ~Brass(){}
};

};

#endif

   1.通过对象调用
     Brass dom("dominic banker",1111,1111.45);
     BrassPlus dot("dorothy banker",1222,222.99);
dom.ViewAcct(); // use Brass::ViewAcct();
dot.ViewAcct(); //use BrassPlus::ViewAcct();

2.通过引用和指针
    如果ViewAcct不是virtual ,则

      Brass dom("dominic banker",1111,1111.45);
     BrassPlus dot("dorothy banker",1222,222.99);

     Brass &b1_ref   = dom;
     Brass &b2_ref = dot;
b1_ref .ViewAcct() ; // use Brass::ViewAcct();
b2_ref.ViewAcct(); //use Brass:ViewAcct();

   如果是Virtual 则
    b1_ref .ViewAcct() ; // use Brass::ViewAcct();
b2_ref.ViewAcct(); //use BrassPlus::ViewAcct();

jz 2008-09-21 16:39 发表评论

第13章类继承 (13.1.2 构造函数:访问权限的考虑)

jz — Sun, 21 Sep 2008 07:39:00 GMT

创建派生类对象时，程序首先创建基类对象。
RatedPlayer::RatedPlayer(unsigned int r, const char* fn, const char* ln, bool ht) : TableTennisPlayer(fn,ln,ht)
{
rating = r;
}

TableTennisPlayer(fn,ln,ht) 调用基类构造函数. 实参传递给TableTennisPlayer.

如果没有成员初始化列表。则程序将使用默认的基类构造函数。
RatedPlayer::RatedPlayer(unsigned int r,const char * fn, const char * ln,bool ht) // TableTennisPlayer() 将调用
{
rating = r;
}

第二种构造函数
RatedPlayer::RatedPalyer(unsigned int r, const TableTennisPlayer &tp): TableTennisPalyer(tp)
{
rating = r;
}

const TableTennisPlayer &tp 调用基类的复制构造函数。如果基类没有定义，则自动生成一个。因为这个类没有动态内存分配。
以上写法还可以写成
RatedPlayer::RatedPalyer(unsigned int r, const TableTennisPlayer &tp): TableTennisPalyer(tp),rating(r)
{
}

jz 2008-09-21 15:39 发表评论

第13章类继承 (13.1.1 派生一个类)

jz — Sun, 21 Sep 2008 07:20:00 GMT

class RatedPlayer : public TableTennisPlayer
{
private:
unsigned int rating;
public:
RatePlayer(unsigned int r= 0 ,const char *fn = "none",const char *ln ="none",bool ht=false);
RatedPlayer(unsigned int r,const TableTennisPlayer & tp);
unsigned int Rating() { return rating;}
void ResetRating(unsigned int r) { rating = r;}
};

关键点:
RatedPlayer(unsigned int r,const TableTennisPlayer & tp);

jz 2008-09-21 15:20 发表评论

第13章类继承 (13.1 一个简单的类)

jz — Sun, 21 Sep 2008 07:04:00 GMT

#include
#include

#ifndef TABTENNO_H_
#define TABTENNO_H_
class TableTennisPlayer
{
private:
enum{ LIM = 20};
char firstname[LIM];
char lastname[LIM];
bool hasTable;
public:
TableTennisPlayer(const char *fn="none", const char *ln="none",bool ht = false);
void Name() const;
bool HasTable() const { return hasTable;}
void ResetTable(bool v)
{
hasTable = v;
}
};
#endif

TableTennisPlayer::TableTennisPlayer(const char *fn , const char *ln , bool ht )
{
std::strncpy(firstname,fn,LIM-1);
firstname[LIM-1] = '\0';
std::strncpy(lastname,ln,LIM-1);
lastname[LIM-1] = '\0';
hasTable = ht;
}

void TableTennisPlayer::Name() const
{
std::cout<

}

int main(void)
{
using std::cout;
TableTennisPlayer player1("chuck","Blizzard",true);
TableTennisPlayer player2("Tarza","Boomdea",false);

player1.Name();
if(player1.HasTable()) //不可直接访问private 成员
{
cout<<":has a table.\n";

}else
{
cout<<":hasn't a table.\n";
}

player2.Name();
if(player2.HasTable())
cout <<":has a table.\n";
else
cout<<":hasn't a table.\n";

return 0;

}

jz 2008-09-21 15:04 发表评论

C++博客-jlz-文章分类-c++ primer plus 读书笔记

第13章 类继承 (13.4 抽象基类)

第13章 类继承 (13.4 单设计模式)

第13章 类继承 (13.4 有关虚函数注意事情)

第13章 类继承 (13.4 指针和引用类型兼容性)

第13章 类继承 (13.4 为何需要虚构函数)

第13章 类继承 (13.4 虚方法实现)

第13章 类继承 (13.4 银行类实现)

第13章 类继承 (13.4 多态公有继乘)

第13章 类继承 (13.1.2 构造函数:访问权限的考虑)

第13章 类继承 (13.1.1 派生一个类)

第13章 类继承 (13.1 一个简单的类)