//头文件：

 #include<iostream>

 #ifndef STACK_H_

 #define STACK_H_

 typedef unsigned long Item;

 class Stack{

 private:

     enum{MAX=};

     Item *pitems;

     int size;

     int top;

 public:

     Stack(int n = );

     Stack(const Stack &st);

     ~Stack();

     bool isempty()const;

     bool isfull()const;

     bool push(const Item & item);

     bool pop();

     Stack & operator=(const Stack & st);

     friend std::ostream & operator<<(std::ostream & os, const Stack &st);

 };

 #endif

 //方法：

 #include<iostream>

 #include<cstring>

 #include"Stack.h"

 using std::cout;

 using std::endl;

 Stack::Stack(int n){

     size = n;

     top = n;

     pitems = new Item[n];

     for (int i = ; i < size; i++)

         pitems[i] = ;

 }

 Stack::Stack(const Stack &st){

     size = st.size;

     top = st.top;

     pitems = new Item[size];

     for (int i = ; i < size; i++)

         pitems[i] = st.pitems[i];

 }

 Stack::~Stack(){

     delete[]pitems;

 }

 bool Stack::isempty()const{

     if (top == )

         return true;

     else return false;

 }

 bool Stack::isfull()const{

     if (top == MAX)

         return true;

     else return false;

 }

 bool Stack::push(const Item & item){

     if (isfull()){

         cout << "the stack is already full" << endl;

         return false;

     }

     else{

         Item *temp;

         temp = new Item[size + ];

         for (int i = ; i < size; i++)

             *(temp + i) = *(pitems + i);

         *(temp + size) = item;

         delete[]pitems;

         pitems = temp;

         size++;

         top++;

         return true;

     }

 }

 bool Stack::pop(){

     if (isempty()){

         cout << "the stack is already empty" << endl;

         return false;

     }

     else{

         Item *temp;

         temp = new Item[size - ];

         for (int i = ; i < (size - ); i++)

             temp[i] = pitems[i];

         delete[]pitems;

         pitems = temp;

         size--;

         top--;

         return true;

     }

 }

 Stack & Stack::operator=(const Stack & st){

     if (this == &st)

         return *this;

     size = st.size;

     top = st.top;

     delete[]pitems;

     pitems = new Item[st.size];

     for (int i = ; i < size; i++)

         pitems[i] = st.pitems[i];

     return *this;

 }

 std::ostream & operator<<(std::ostream & os, const Stack &st){

     os << "size: " << st.size << endl

         << "top: " << st.top << endl;

     for (int i = ; i < st.size; i++)

         os << st.pitems[i] << " ";

     return os;

 }

 //驱动：

 #include<iostream>

 #include<cstdlib>

 #include"Stack.h"

 using namespace std;

 int main(){

     Stack ct1;

     Stack ct2();

     cout << "ct1 "<< ct1 <<endl;

     cout << "ct2 "<< ct2 <<endl;

     Stack ct3 = ct2;

     cout << "ct3 "<< ct3 << endl;

     ct1 = ct2;

     cout << "ct1 " << ct1 << endl;

     ct2.push();

     cout << "ct2 " << ct2 << endl;

     ct1.pop();

     cout << "ct1 "<< ct1 << endl;

     system("pause");

     return ;

 }

 //头文件：

 class Cd{

 private:

     char performers[];

     char label[];

     int selections;

     double playtime;

 public:

     Cd(char *s1, char *s2, int n, double x);

     Cd(const Cd & st);

     Cd();

     virtual ~Cd();

     virtual void Report()const;

     Cd & operator = (const Cd & st);

 };

 class Classic : public Cd

 {

 private:

     char production[];

 public:

     Classic(char *s1 = "nullbody1", char *s2 = "nullbody2", char *s3 = "nullbody3", int n = , double x = );

     Classic(const Classic & st);

     virtual void Report()const;

     Classic & operator=(const Classic & st);

 };

 //方法：

 #include<iostream>

 #include<cstring>

 #include"classic.h"

 using std::cout;

 using std::endl;

 Cd::Cd(char *s1, char *s2, int n, double x){

     strncpy(performers, s1, );

     performers[] = '\0';

     strncpy(label, s2, );

     label[] = '\0';

     selections = n;

     playtime = x;

 }

 Cd::Cd(const Cd & st){

     strcpy(performers, st.performers);

     strcpy(label, st.label);

     selections = st.selections;

     playtime = st.playtime;

 }

 Cd::Cd(){

     selections = ;

     playtime = ;

 }

 void Cd::Report()const{

     cout << "performers: " << performers << endl

         << "label: " << label << endl

         << "selections: " << selections << endl

         << "playtime: " << playtime << endl;

 }

 Cd & Cd::operator = (const Cd & st){

     if (this == &st)

         return *this;

     strcpy(performers, st.performers);

     strcpy(label, st.label);

     selections = st.selections;

     playtime = st.playtime;

     return *this;

 }

 Classic::Classic(char *s1, char *s2, char *s3, int n, double x): Cd(s2, s3, n, x){

     strncpy(production, s1, );

     production[] = '\0';

 }

 Classic::Classic(const Classic & st): Cd(st){

     strcpy(production, st.production);

 }

 Cd::~Cd(){

 }

 void Classic::Report()const{

     cout << "production: " << production << endl;

     Cd::Report();

 }

 Classic & Classic::operator=(const Classic & st){

     if (this == &st)

         return *this;

     Cd::operator=(st);

     strcpy(production, st.production);

     return *this;

 }

 //驱动：

 #include<iostream>

 #include<cstdlib>

 using namespace std;

 #include"classic.h"

 void Bravo(const Cd & disk);

 int main(){

     Cd c1("Beatles", "Capitol", , 35.5);

     Classic c2 = Classic("piano sonata in B flat", "Alfred Brendel", "Philips", , 57.17);

     Cd *pcd = &c1;

     cout << "using object directly\n";

     c1.Report();

     c2.Report();

     cout << "using type cd *pointer to objects:\n";

     pcd->Report();

     pcd = &c2;

     pcd->Report();

     cout << "calling a function with a Cd reference argument:\n";

     Bravo(c1);

     Bravo(c2);

     cout << "testing assignment: ";

     Classic copy;

     copy = c2;

     copy.Report();

     system("pause");

     return ;

 }

 void Bravo(const Cd & disk){

     disk.Report();

 }