class Foo { 
public: 
  Foo(); // 構(gòu)造函數(shù) 
  Foo(string &s); 
  // ... 
}; 

class Foo { 
public: 
  Foo(); 
  Foo(const Foo&); // 拷貝構(gòu)造函數(shù) 
  // ... 
}; 

class Foo { 
public: 
  Foo(); 
  Foo& operator=(const Foo&); // 賦值運(yùn)算符 
  // ... 
}; 

class Foo { 
public: 
  ~Foo(); // 析構(gòu)函數(shù) 
  // ... 
}; 

class DArray 
{ 
private: 
  double *m_Data; // 存放數(shù)組的動(dòng)態(tài)內(nèi)存指針 
  int m_Size;   // 數(shù)組的元素個(gè)數(shù) 
  int m_Max;    // 預(yù)留給動(dòng)態(tài)數(shù)組的內(nèi)存大小 
private: 
  void Init();   // 初始化 
  void Free();   // 釋放動(dòng)態(tài)內(nèi)存 
  inline bool InvalidateIndex(int nIndex); // 判斷下標(biāo)的合法性 
public: 
  DArray();    // 默認(rèn)構(gòu)造函數(shù) 
  DArray(int nSize, double dValue = 0); // 構(gòu)造函數(shù)，設(shè)置數(shù)組大小，默認(rèn)值為dValue 
  DArray(const DArray& arr); // 拷貝構(gòu)造函數(shù) 
  DArray& operator=(const DArray& arr); // 拷貝賦值運(yùn)算符 
  ~DArray();    // 析構(gòu)函數(shù) 
 
  void Print();  // 輸出顯式所有數(shù)組元素的值 
  int GetSize();  // 獲取數(shù)組的大小（元素個(gè)數(shù)） 
  void SetSize(int nSize); // 重新設(shè)置數(shù)組的大小，若nSize小于原大小，截?cái)?；否則，新元素置0 
  double GetAt(int nIndex); // 獲取指定位置元素 
  void SetAt(int nIndex,double dValue); // 重置指定元素的值 
  void PushBack(double dValue); // 追加一個(gè)新元素到數(shù)組末尾 
  void DeleteAt(int nIndex);   // 刪除指定位置地元素 
  void InsertAt(int nIndex, double dValue); // 插入一個(gè)新的元素到數(shù)組中 
  double operator[](int nIndex) const;   // 重載下標(biāo)運(yùn)算符[] 
}; 

void DArray::Init() 
{ 
  m_Size = 0;  // 默認(rèn)情況下數(shù)組不包含元素 
  m_Max = 1; 
  m_Data = new double[m_Max]; 
} 
 
void DArray::Free() 
{ 
  delete [] m_Data; 
} 
 
bool DArray::InvalidateIndex(int nIndex) 
{ 
  if(nIndex>=0 && nIndex<m_Size) 
    return false; 
  else 
    return true; 
} 
 
// 默認(rèn)構(gòu)造函數(shù) 
DArray::DArray() 
{ 
  Init(); 
} 
 
// 構(gòu)造函數(shù) 
DArray::DArray(int nSize, double dValue) 
{ 
  if(nSize == 0) 
    Init(); 
  else 
  { 
    m_Size = nSize; 
    m_Max = nSize; 
    m_Data = new double[m_Max]; 
    for(int i=0; i<nSize; ++i) 
      m_Data[i]=dValue; 
  } 
} 
 
// 拷貝構(gòu)造函數(shù) 
DArray::DArray(const DArray& arr) 
{ 
  m_Size = arr.m_Size; /*復(fù)制常規(guī)成員*/ 
  m_Max = arr.m_Max; 
  m_Data = new double[m_Max];  /*復(fù)制指針指向的內(nèi)容*/ 
  memcpy(m_Data, arr.m_Data, m_Size*sizeof(double)); 
} 
 
// 拷貝賦值運(yùn)算符 
DArray& DArray::operator=(const DArray& arr) 
{ 
  if(this == &arr) /*自賦值*/ 
    return *this; 
  m_Size = arr.m_Size; 
  m_Max = arr.m_Max; 
  /* 先將右側(cè)對(duì)象拷貝到臨時(shí)對(duì)象中，然后再銷毀左側(cè)對(duì)象*/  
  double *m_Temp = new double[m_Max]; 
  memcpy(m_Temp, arr.m_Data, m_Size*sizeof(double)); 
  delete [] m_Data; 
  m_Data = m_Temp; 
 
  return *this; 
} 
 
// 析構(gòu)函數(shù) 
DArray::~DArray() 
{ 
  Free(); 
} 
 
// 打印數(shù)組 
void DArray::Print() 
{ 
  if(m_Size == 0) 
  { 
    cout << "Error: The empty array can't be Printed." << endl; 
    exit(0); 
  } 
  else 
  { 
    for(int i=0; i<m_Size; ++i) 
      cout << m_Data[i] << " "; 
    cout << endl; 
  } 
} 
 
// 獲取數(shù)組大小 
int DArray::GetSize() 
{ 
  return m_Size; 
} 
 
// 重置數(shù)組大小 
void DArray::SetSize(int nSize) 
{ 
  if(nSize < m_Size)  /*截?cái)?/ 
  { 
    for(int i=nSize; i<m_Size; ++i) 
      m_Data[i] = 0; 
  } 
  if(m_Size<=nSize && nSize<=m_Max) /*新增元素置0*/ 
  { 
    for(int i=m_Size; i<nSize; ++i) 
      m_Data[i] = 0; 
  } 
  if(nSize > m_Max)  /*需要重新分配空間*/ 
  { 
    m_Max = nSize; 
    double *temp = new double[m_Max]; 
    memcpy(temp, m_Data, m_Size*sizeof(double)); 
    for(int i=m_Size; i<nSize; ++i) 
      temp[i] = 0; 
    delete [] m_Data; 
    m_Data = temp; 
  } 
  m_Size = nSize; /*設(shè)置數(shù)組大小*/ 
} 
 
// 獲取指定位置元素 
double DArray::GetAt(int nIndex) 
{ 
  if(InvalidateIndex(nIndex)) 
  { 
    cout << "Error: the index of GetAt is invalid!" << endl; 
    exit(0); 
  } 
  return m_Data[nIndex]; 
} 
 
// 設(shè)置指定位置元素的值 
void DArray::SetAt(int nIndex, double dValue) 
{ 
  if(InvalidateIndex(nIndex)) 
  { 
    cout << "Error: the index of SetAt is invalid!" << endl; 
    exit(0); 
  } 
  else 
  { 
    m_Data[nIndex] = dValue; 
  } 
} 
 
// 追加一個(gè)新元素到數(shù)組末尾 
void DArray::PushBack(double dValue) 
{ 
  if(m_Size < m_Max) 
  { 
    m_Data[m_Size] = dValue; 
  } 
  else  
  { 
    m_Max = m_Max*2; 
    double* temp = new double[m_Max]; 
    memcpy(temp, m_Data, m_Size*sizeof(double)); 
    delete [] m_Data; 
    m_Data = temp; 
    m_Data[m_Size] = dValue; 
  } 
  ++m_Size; /*數(shù)組大小加1*/ 
} 
 
// 從數(shù)組中刪除一個(gè)元素 
void DArray::DeleteAt(int nIndex) 
{ 
  if(InvalidateIndex(nIndex)) 
  { 
    cout << "Error: the index of DeleteAt is invalid." << endl; 
    exit(0); 
  } 
  else 
  {   
    for(int i=nIndex; i<m_Size; ++i) 
      m_Data[i] = m_Data[i+1]; 
    m_Data[m_Size-1] = 0; 
    --m_Size; 
  } 
} 
 
// 插入一個(gè)新元素到指定位置 
void DArray::InsertAt(int nIndex, double dValue) 
{ 
  if(nIndex<0 || nIndex>m_Size) 
  { 
    cout << "Error: the index of InsertAt is invalid!" << endl; 
    exit(0); 
  } 
 
  if(m_Size < m_Max) /* 未滿，插入 */ 
  { 
    for(int i=m_Size-1; i>=nIndex; --i) 
      m_Data[i+1] = m_Data[i]; 
    m_Data[nIndex] = dValue; 
  } 
  else        /* 重新分配空間 */ 
  { 
    m_Max = m_Max*2; 
    double* temp = new double[m_Max]; 
    memcpy(temp, m_Data, m_Size*sizeof(double)); 
    delete [] m_Data; 
    m_Data = temp; 
    for(int i=m_Size-1; i>=nIndex; --i) 
      m_Data[i+1] = m_Data[i]; 
    m_Data[nIndex] = dValue; 
  } 
  ++m_Size; /* 數(shù)組大小加1 */ 
} 
 
// 重載下標(biāo)運(yùn)算符[] 
double DArray::operator[](int nIndex) const 
{ 
  if(nIndex<0 || nIndex>=m_Size) 
  { 
    cout << "Error: the index in [] is invalid!" << endl; 
    exit(0); 
  } 
  return m_Data[nIndex]; 
} 

class String{  
  friend ostream& operator<< (ostream&,String&); //重載<<運(yùn)算符  
  friend istream& operator>> (istream&,String&); //重載>>運(yùn)算符  
public:  
  String();  // 默認(rèn)構(gòu)造函數(shù) 
  String(const char* str);    // 帶參構(gòu)造函數(shù)  
  String(const String& rhs);    // 拷貝構(gòu)造函數(shù)  
  String& operator=(const String& rhs);  // 拷貝賦值運(yùn)算符  
  String operator+(const String& rhs) const; //operator+  
  bool operator==(const String&);       //operator== 
  bool operator!=(const String&);       //operator!=   
  char& operator[](unsigned int);       //operator[]  
  size_t size() const;  
  const char* c_str() const; 
  ~String();  // 析構(gòu)函數(shù)  
private:  
  char *m_data; // 用于保存字符串  
};