在前一章中，我們已經為讀者說明了在應用程式構思階段的兩件重要的抽象化工作：決定代表應用程式的物件導向世界要由哪些物件所組成，並決定每個物件的屬性、行為及物件與物件間的關係。為了要建構物件導向世界，我們首先必須依據構思階段的決定來定義類別(Class)，然後再用類別來產生所需的物件(Object)。本章將說明並示範如何使用C++語言來完成類別的定義，以及如何產生物件。

完成前一節的構思後，我們已經掌握了在物件導向世界裡應該會有哪些物件存在，但問題是，在你動手建構這個世界之前，你有沒有先定義這些物件的屬性與行為呢？換句話說，有沒有先定義其所屬的類別呢？ 更具體來說，在構思完成後，你還有以下的工作要進行：

• 將物件所屬的類別先加以定義 — 依據構思時所決定的物件屬性與行為，將真實或虛擬世界中的人、事、時、地、物等抽象化為程式語言中的類別。定義各物件所屬的類別。

• 宣告與建立各式類別的物件 — 依據需求在程式中宣告並產生各個類別的物件。我們把依據類別定義產生物件的動作實體化(Instantiate)，至於產生出的物件被稱為物件實體(Object Instance)

• 實現程式所需提供的各式功能 — 透過設定或改變物件的屬性數值、呼叫物件的函式、進行物件與物件間的互動或是訊息的傳遞等，來加以實現(當然這部份就必須等我們學到更多C++語言類別與物件的相關語法後，才能繼續加以討論)。

至於類別的定義其實並不困難，正如我們已經在之前的討論中所看到過的一樣，只要使用類似結構體的定義方式，將類別相關的屬性及行為加以定義即可。但在開始介紹類別定義語法前，先讓我們說明一下與類別相關的術語，因為物件導向在不同程式語言所使用的術語並不一致，所以有時會發生同樣一個東西在不同地方卻會看到不一樣的名詞的困擾；table 1將在談論物件導向概念時，類別的屬性與行為這兩個名詞，在C++語言、Java語言以及UML所使用的名詞加以彙整，請讀者自行加以參考；其中對我們現階段最為重要的就是C++語言，它是使用「資料成員(Data Member)」與「成員函式(Member Function)」來稱呼類別的屬性與行為。

現在，請參考以下的C++語言類別定義語法：

其語法上大致與結構體的定義相同，除了必須提供類別名稱以外，還要記得在大括號裡的開頭處寫下「public:」(關於此點我們將在下一章進行說名)，另外就是在其大括號的內部宣告相關的資料成員與成員函式，請參考以下的說明：

• 資料成員(Data Member)：此部份就如同結構體一樣，可以定義多個與此類別相關的資料項目，但要注意的是它並不允許在宣告變數時給定初始值(但從C++11起已允許初始值給定)。
• 成員函式(Member Function):此部份語法就如同原本C++語言的函式定義一樣，只不過現在是寫在類別內部。

以下我們使用本章前面所使用的客戶與學生範例，示範如何使用C++語言進行Customer類別與Student類別的定義：

class Customer
{
public:
   string name;
   string ID;
   string accountNo;
   int    balance;
   int interest(double rate)
   {
      return balance*rate;
   }
};

class Student
{
public:
   string name;
   string SID;
   int    score;
   bool isPass()
   {
      return (score>=60);
   }
};

上面的例子相信讀者應該很容易理解，在此不另行說明。不過前面我們也提到，C++語言已經把結構體升級為2.0，所以以下的結構體定義也是正確的：

struct Customer
{
   string name;
   string ID;
   string accountNo;
   int    balance;
   int interest(double rate)
   {
      return balance*rate;
   }
};

struct Student
{
   string name;
   string SID;
   int    score;
   bool isPass()
   {
      return (score>=60);
   }
};

雖然你現在不論怎麼看，都只會覺得C++語言的類別與結構體定義除了一個用class、一個用struct以外，一個有寫public、一個沒寫以外，它們根本是完全相同的！但是筆者要提醒讀者，它們兩者間還是存在著其它差異，但現在還不是為你揭曉的時候，等到下一章我們介紹到存取控制後，自然就能向你說明、讓你明白。不過如果是過去已經學過C語言的讀者，你現在至少看得出結構體1.0和2.0的差別了 — 1.0只能定義結構體相關的資料項目，2.0還可以定義專供其使用的函式！

本節最後要提醒讀者，完成類別的定義以後，我們就可以把類別視為模具，未來就可以在程式裡面用來生產物件了！

接續前一小節的類別定義，現在我們就可以將類別視為模具，並用來生產物件了。請參考以下的程式碼，雖然它看起來就好像將Student類別視為型態，並宣告了一個變數bob，但是它其實是幫我們產生出一個“Student類別的物件”：

Student bob;

更具體來說，上面這行宣告敘述將會在記憶體裡產生Student類別的物件實體，並且使用物件變數名稱bob做為後續存取該物件實體的資料成員與呼叫其成員函式的識別字。

等等… 完全看不懂你在說什麼…

別擔心，看不懂是正常的。本節的目的就是要讓你能夠看懂它…

筆者想先問讀者們一個問題：

「我們將Student類別視為型態所宣告的變數bob到底是什麼？」

前面不是有說過，不就是物件嗎？

嗯，這個回答算是一半對、一半不對！ 讓我們先回想一下變數到底是什麼？請參考以下的程式碼：

int x;
...
x=38;

在上面這段簡單的程式裡，其實有一些編譯時的細節你必須明瞭。還記得我們在第14章 淺談記憶體管理所介紹過的自動變數嗎？此處所宣告的「int x;」就是一個自動變數，假設int整數佔4個Bytes，當編譯器編譯到「int x;」這行宣告時，會在記憶體裡面配置一塊連續4個Bytes的空間供其使用，假設是配置在從0x7fffffff0380到0x7fffffff0383的記憶體位址裡(請參考figure 1(a))。完成記憶體配置後，編譯器會把|x|int|0x7fffffff0380|等資訊寫入到符號表裡(如figure 1(b))。

當後續處理到運算敘述「x=38;」時，編譯器(其實完全不知道x是什麼東東，所以)必須去符號表裡搜尋看看能不能找到x。當然在此例裡，其搜尋結果顯示x是一個int整數且被配置到0x7fffffff0380位址開頭的記憶體空間，因此編譯器才有能力完成「x=38;」的運算敘述 — 將整數值38以二進制的方式保存在記憶體位址0x7fffffff0380到0x7fffffff0383裡面。

至此，我們完成了上述程式碼在編譯過程中的細節說明。現在，你覺得變數是什麼？其實在上述程式碼裡面的x對於編譯器來說，它只不過是一個符號而已，就像每個人一個都有一個“名字”，“名字”本身並不是“真正的你”，只不過是一個“用來識別你的方法”而已。所以在程式碼中的x就只是一個「識別字(Identifier)」，我們所有透過x所進行的動作，最終都必須作用在“所配置的記憶體空間」裡；就好比不管”真正的你“長高了幾公分，你的名字也不會跟著長高一樣，「x=38;」的作用，並不是把x變成38，而是把38放到x所代表的那塊記憶體空間裡。

所以到底變數是什麼？變數是一塊在記憶體裡的連續空間，空間的大小由其型態決定，並可用來存放特定的數值。那什麼又是變數名稱呢？ 變數名稱只是一個識別字，用以幫助我們以及編譯器去識別那些在記憶體裡面真正用來存放數值的連續空間。不過在習慣上，絕大部份的程式設計師都是用抽象的方式，直接將變數名稱就視為是變數(例如直接把x視為變數)，請參考figure 1(c)。儘管你現在已經學習到「變數x」真正的意涵應該是「在記憶體裡的某塊可以使用x加以識別的連續空間」，但是筆者還是建議你維持原本的稱呼方法，還是直接簡單一點用抽象的方式稱呼為「變數x」就好 — 這就是抽象的意思，把複雜的細節隱藏起來，讓我們更容易於溝通與表達並專注於邏輯上的意涵。試想以「x=x+y;」為例，你是想要完全不抽象、完完整整的說成：「把在記憶體裡的某兩塊可以使用x與y加以識別的連續空間裡的數值相加，並把結果放到在記憶體裡的某塊可以使用x加以識別的連續空間裡。」，還是選擇抽象一點、簡化一點，直接說成「把變數x和y的數值相加，並把結果放到變數x裡」？ 我想大部份的人都會選擇後者。

現在，讓我們回到用以產生Student類別的物件的宣告敘述:

Student bob;

經過前面對於變數x的討論，讓我們再回到開頭所討論的問題：

「我們將Student類別視為型態所宣告的變數bob到底是什麼？」

如果問題裡的”變數bob“指得是宣告後所配置到的記憶體空間，那麼我的答案是「物件」！

因為像是「Student bob;」這樣的宣告敘述，其實會在記憶體裡面得到一塊可以放得下”Student類別的物件“的記憶體空間(如果你對於Student類別的物件佔多少記憶體空間感到好奇，你可以使用sizeof去找到答案)，並以bob做為識別字，幫助我們在後續的程式裡去使用配置給”Student類別的物件“的記憶體空間，包含去存取它的資料成員以及呼叫它的成員函式。

但如果問題裡的”變數bob“指得就是bob，那麼很抱歉，我的答案是它們是變數名稱、是識別字，是用來幫助我們(與編譯器)去找到、去使用在記憶體裡配置給物件的空間。

其實像是「Student bob;」這樣的宣告敘述，和「int x;」一樣是使用自動配置的記憶體空間，所以它會被”自動“的配置到一塊適合Student類別大小的空間供其使用，而這個所配置到的空間裡的內容就是依據Student類別的定義所配置的，裡面可用來存放其所有相關的資料成員，以及它的成員函式的程式碼，請參考figure 2 — 這塊在記憶體空間才”物件“的本體，依物件導向的術語還可以將其稱為「物件實體(Object Instance)」。至於那個宣告時所使用的bob，只是一個識別字，它只是用來幫助我們在後續的程式裡去使用”物件實體“(也就是幫我們去存取那塊配置給物件使用的記憶體空間)。

釐清了相關觀念後，現在讓我們再回答一次：

「我們將Student類別視為型態所宣告的變數bob到底是什麼？」

bob是什麼？bob是一個識別字，它可以用來幫我們存取在記憶體裡Student類別的物件實體的資料成員，或是呼叫其成員函式。

最後，就如同我們所討論過的「變數x」與「在記憶體裡的某塊可以使用x加以識別的連續空間」一樣，儘管我們現在已經明白「Student bob;」的相關細節，但如果每次都把物件說成「在記憶體裡的某塊依據Student類別所加以配置的連續空間」、把bob說成「可以用來存取在記憶體裡的某塊依據Student類別所加以配置的連續空間的資料成員，以及呼叫該塊連續空間裡的成員函式的識別字」，似乎也太過於麻煩和太過於精確了。筆者建議使用以下的方法稱呼它們:

• 物件/物件實體：在記憶體裡配置的空間叫做物件，這點是沒有疑問的，但可以稱為「物件實體」會更為精確。
• 物件變數：至於宣告類別物件時所使用的名稱，儘管只是個識別字，但就像「變數x」一樣，還是有人也抽象地它為「物件」，不過筆者覺得這樣很容易和”物件實體“混淆，所以建議的稱呼是「物件變數」。

好了，最後讓我們再回答一次：

「我們將Student類別視為型態所宣告的變數bob到底是什麼？」

bob是在記憶體裡面的一個Student類別的物件實體的變數名稱

嗯，回答得很好！可以再…再簡化一點嗎？

bob是Student類別的物件變數！

太棒了！聽起來你已經完全搞懂了！

依據類別定義在記憶體裡配置空間給其物件使用這件事情，就稱為物件的實體化(Object Instantiate) — 就是把物件實體產生出來的意思！本節將說明C++語言如何進行物件的實體化，並介紹如何為其資料成員進行初始值給定。

首先第一種方式就是宣告物件變數，可在定義類別後將類別視為型態進行變數宣告，或是在定義類別的同時進行宣告(就好像結構體一樣)：

class Student
{
public:
   string name;
   string SID;
   int    score;
   bool isPass()
   {
      return (score>=60);
   }
};

Student bob;

class Student
{
public:
   string name;
   string SID;
   int    score;
   bool isPass()
   {
      return (score>=60);
   }
} bob;

正如我們在上一節所說明過的，上面的做法將會”自動“地配置一塊適合Student類別的物件的記憶體空間 — 換句話說，Student類別的一個物件實體被”自動“地產生出來了。此部份的概念，也可以參考figure 2。

如同變數的宣告一樣，類別的定義以及物件的宣告在程式中的位置就決定了它們可以被使用的地方，以下是將類別定義為全域的(意即將它宣告於所有函式之外)例子：

#include <iostream>
using namespace std;

class Student // Student類別定義是全域的
{
public:
   string name;
   string SID;
   int    score;
   bool isPass()
   {
      return (score>=60);
   }
} bob; // 使用全域的Student類別宣告全域的bob物件變數

Student robert; // 使用全域的Student類別宣告全域的robert物件變數

int main()
{
   Student alice; // 使用全域的Student類別宣告區域的alice物件變數
...
   // 此處除alice區域物件變數外，另有bob與robert全域物件變數可以使用
}

在上面的例子裡，由於Student類別被定義於所有的函式以外，所以它是屬於所謂的「全域類別定義(Global Class Definition)」，可以在程式的任何地方被使用 — 例如我們分別在第14、16與19行使用此全域類別來宣告物件變數bob、robert與alice；又因為它們被宣告的位置不同，其中bob與robert是全域的物件變數，至於alice則是宣告在main()函式裡的區域變數。

既然有全域類別，那當然也會有所謂的區域類別(Local Class)，請參考下面的例子：

#include <iostream>
using namespace std;

Student robert; // 此行會發生編譯錯誤，因為全域的Student類別定義並不存在

int main()
{
   class Student // 定義在main()函式內部的Student類別，是僅限於main()函式裡使用的區域類別
   {
   public:
      string name;
      string SID;
      int    score;
      bool isPass()
      {
         return (score>=60);
      }
   } bob; // 使用區域的Student類別宣告區域的bob物件變數

   Student alice; // 使用區域的Student類別宣告區域的alice物件變數
...
   // 此處僅有bob與alice區域物件變數可以使用
}

有的時候，我們在程式裡所定義的類別(不論全域或區域類別)可能只有被用來進行一次物件宣告，且在後續的程式碼裡都沒有再次使用到該類別；要知道，儘管它是一次性的，但在定義時，我們還是必須完整地為此類別命名、定義資料成員與成員函式。C++語言針的這種情況，提供”可省略類別名稱“的做法，我們將其稱為「匿名類別(Anonymous Class)」 — 沒有名字的類別(或是叫做”不需要名字的類別“更為恰當啦。請參考以下的範例：

#include <iostream>
using namespace std;

int main()
{
   class // 在main()函式裡定義一個匿名的區域類別
   {
   public:
      string name;
      string SID;
      int    score;
      bool isPass()
      {
         return (score>=60);
      }
   } bob; // 宣告此匿名類別的區域物件變數
...
}

#include <iostream>
using namespace std;

class // 定義一個匿名的全域類別
{
public:
   string name;
   string SID;
   int    score;
   bool isPass()
   {
      return (score>=60);
   }
} bob; // 宣告此匿名類別的全域物件變數

int main()
{
...
}

讓我們再回顧一下figure 2：

細心的讀者應該已注意到在figure 2裡，物件實體裡的資料成員都是空白的，這代表它們還沒有被賦與任何的初始值。自C++11起，支援給定類別資料成員預設值(Default Member Value)，請參考下例(必須使用-std=C++11或-std=gnu11編譯器參數)： <sxh cpp; title:類別資料成員預設值範例 defaultMemberValue.cpp; highlight:[7-9,14-17]> #include <iostream> using namespace std; class Student { public: string name="noname"; string SID="noID"; int score=0; bool isPass() { return (score>=60); } void showInfo() { cout << name << "(" << SID << ") " << score << endl; } }; int main() { Student bob, robert, alice; bob.showInfo(); robert.showInfo(); alice.showInfo(); } </sxh> 此程式在第7至9行為所有的資料成員設定了數值，這些數值被稱為預設值，請參考<imgref Fig_defaultvalue>，你可以看出現在依據Student類別所產生的所有物件實體的資料成員都會具有這些數值： <WRAP center> <imgcaption Fig_defaultvalue center 依據類別定義(含成員預設值)產生的物件實體> </imgcaption> </WRAP> 另外，為了便利理解此程式的執行結果，我們在第14-19行新增了一個成員函式showInfo()，它會將物件的資料成員的數值加以輸出，其執行結果如下：

noname (noID) 0
noname (noID) 0
noname (noID) 0

不同於上一小節所提到的資料成員預設值，本節將介紹的資料成員初始值給定(Data Member Initialization)是指在產生物件時對於資料成員設定的初始數值(Initial Value)。我們在13.1.1 結構體變數裡所提到的結構體變數的初始值給定方法，也適用於類別的物件實體 — 在類別物件變數宣告時以「＝{ … }」方式，依類別定義資料成員的順序進行給定即可，請參考下面的例子

class Student 
{
public:
   string name="noname";
   string SID="noID";
   int    score=0;
   bool isPass()
   {
      return (score>=60);
   }
} bob={"Bob Dylan", "CBB11100000", 100};

Student robert={"Robert", "CBB11100001", 59};
Student alice; // 未給定初始值，所以依資料成員預設值給定

若不想依據宣告時的順序，或是有想要忽略的資料成員，那麼就如同結構體一樣可以使用指定初始子(Designated Initializer)來加以完成，請參考以下的例子：

Student bob={.name="Bob", .SID="CBB01", .score=100}; // 可使用指定初始子註明所要設定初始值的資料成員
Student robert={.score=59, .SID="CBB02", .name="Robert"}; // 可不依原宣告順序
Student alice={.SID="CBB03", .name="Alice"}; //缺少初始值給定的score資料成員將會依資料成員預設值給定

除了利用物件變數宣告讓C++幫我們”自動“產生物件實體以外，還有另外一種產生物件實體的方法，透過new與delete來自行決定何時要產生物件實體所需的記憶體空間，何時又要將其加以收回 — 我們把這種做法稱為「動態記憶體配置(Dynamic Memory Allocation)」，或是稱為「物件實體化(Object Instantiation)」。關於new與delete可參考本書14.3 動態儲存。 以下的程式碼依據Student類別的定義，在記憶體裡面動態配置一塊空間：

new Student;

cout << hex << (new Student);

0x60000144c200

好了，我們動態產生了一個物件實體，它被配置在0x60000144c200的位址，然後呢？我們要如何使用它呢？答案是用指標，請參考下面的程式碼：

#include <iostream>
using namespace std;
 
class Student 
{
public:
   string name="noname";
   string SID="noID";
   int    score=0;
   bool isPass()
   {
      return (score>=60);
   }
   void showInfo()
   {
      cout << name << "(" << ID << ") " << score << endl;
   }
}; 
 
int main()
{
   Student *bob = new Student;
   bob->showInfo();
   (*bob).showInfo();

}

當然，我們也可以用比較抽象的方式來看待，請參考figure 6：

另外，要提醒讀者注意的是，當透過指標來使用物件實體時，就好比透過指標來使用結構體時一樣，要存取其資料成員與成員函式時，必須改用 -> 成員選取運算子(Member Selection Operator)，又叫作成員選取子(Member Selector)。例如在上述程式中的第23行，我們透過bob指標去使用Student類別的物件實體裡面的showInfo()成員函式 —「bob->showInfo();」。 當然，我們也可以先用 * 間接存取運算子(Indirect Access Operator)，來取得指標所指向之處的值(此處的”值“為物件實體)，然後就可以使用原本的 . 來呼叫它的成員函式，例如第24行的「(*bob).showInfo();」。

當然，我們也可以動態建立物件實體的陣列：

#include <iostream>
using namespace std;
 
class Student 
{
public:
   string name="noname";
   string SID="noID";
   int    score=0;
   bool isPass()
   {
      return (score>=60);
   }
   void showInfo()
   {
      cout << name << "(" << ID << ") " << score << endl;
   }
}; 
 
int main()
{
  Student *cise1A = new Student [50];
  Student *someone;

  csie1A[0].name="Amy";  //陣列元素是物件實體，所以使用.
  caie1A[0].showInfo();
  someone=csie1A;
  someone++;
  someone->name="Jacky";  //someone是指標，所以用->
  (*someone).showInfo();
  
  delete [] csie1A;
  return 0;
}

通常，我們會將類別的定義與實作分開放在不同的檔案： === 類別定義 ===

#ifndef _STUDENT_
#define _STUDENT_

class Student
{
public:
  string name;
  string SID;
  int    score;
  bool   isPass();
  void   showInfo();
};
#endif

#include <iostream>
#include "student.h"
using namespace std;

bool Student::isPass()
{
   return score>=60;
}

void Student::showInfo()
{
  cout << name << "(" << SID << ") " << score << endl;
}

#include <iostream>
#include "student.h"
using namespace std;

int main()
{
  Student *bob = new Student;
  bob->name="Bob";
  bob->SID="CBB01";
  bob->score=100;
  bob->showInfo();
}

g++ -c student.cpp
g++ main.cpp student.o -o main

這時只要搭配Makefile就可以輕鬆地完成編譯的動作：

all: student.o
        g++ main.cpp studnet.o -o main

student.o: student.cpp
        g++ -c student.cpp

clean:
        rm -f *.o main *.*~ *~

class Student
{
public:
  string name;
  string SID;
  int    score;
  bool   isPass();
  void   showInfo();
};

inline void Student::showInfo()
{
  cout << name << "(" << SID << ") " << score << endl;
}

class Student
{
public:
  string name;
  string SID;
  int    score;
  bool   isPass()
  {
     return score>=60;
  }
  
  void   showInfo()
  {
     cout << name << "(" << SID << ") " << score << endl;
  }
};

請回顧一下前面使用Student類別的物件實體的程式，若使用動態配置記憶體的方法，則通常會有以下這一行：

Student *bob = new Student;

Student *bob = new Student();

Student() { }

Student() 
{
   name="unknown";
   SID ="unknown";
   score=0;
}

> 還記得第10章 函式介紹過的「同名異式」函式多載嗎？你也可以使用這個方法來提供不同版本的建構函式，例如:

Student (string n, string i) 
{
   name=n;
   SID=i;
   score=0;
}

Student (string n, string i, int s) 
{
   name=n;
   SID=i;
   score=s;
}

Student *bob = new Student("Bob", "CBB01");
Student *robert = new Student("Robert", "CBB02", 99);

#ifndef _STUDENT_
#define _STUDENT_

class Student
{
public:
  string name;
  string SID;
  int    score;
  Student (string n, string i, int s);
  bool   isPass();
  void   showInfo();
};
#endif

#include <iostream>
#include "student.h"
using namespace std;

Student::Student(string n, string i, int s)
{
  name=n;
  SID=i;
  score=s;
}

bool Student::isPass()
{
   return score>=60;
}
  
void Student::showInfo()
{
   cout << name << "(" << SID << ") " << score << endl;
}

#include <iostream>
#include "student.h"
using namespace std;

int main()
{
  Student *bob = new Bob;
  bob->showInfo();
}

Student::Student()
{
   do whatever you like!
}

學會了類別的建構函式該如何撰寫後，本節將介紹一個專屬於建構函式的「成員初始化串列(Member Initializer List)」，用以在建構出物件實體時將指定的資料成員進行初始值的設定。成員初始化串列的語法是在建構函式後，使用一個冒號:並將所要設定初始值的資料成員的名稱及數值依下列語法進行設定：

依據上述的語法，若要設定一個以上的資料成員初始值時，可以使用逗號加以分隔。另外，語法中的「運算式」的運算元可以是數值、建構函式的參數以及該類別的資料成員，但其運算結果必須與所要設定的資料成員型態一致(否則將啟動自動型態轉換，且當無法轉換為所需的資料型態時，就會得到編譯錯誤)。請參考下面的範例：

Student::Student(string n, string i, int s): name(n), SID(i), score(s>100?100:s)
{
}

Student::Student(): name("unknown"), SID(name), score(0)
{
}

Student::Student(): SID("unknown"), name(SID), score(0)
{
}

除了建構函式之外，C++也會在我們進行delete以回收不再需要的物件實體時、或是當物件實體的生命週期結束時(例如在函式內的區域物件變數離開函式範圍，或是全域類別變數遇到程式執行結束時)，呼叫一個特別的成員函式，稱為「解構函式(destructor)」或「解構子」。如果你並沒有提供解構函式，那麼編譯器也會自動幫我們產生下面的函式：

Student::~Student() {  }

Student::~Student()
{
   cout << "Bye!" << endl;
}

#ifndef _STUDENT_
#define _STUDENT_

class Student
{
public:
  char *name;
  char *SID;
  int   score;
  Student();
  ~Student();
  bool   isPass();
  void   showInfo();
};#endif

#include <iostream>
#include "student.h"
using namespace std;

Student::Student()
{
  name = new char[20];
  SID = new char[10];
}

Student::~Student()
{
  delete [] name;
  delete [] SID;
}

bool Student::isPass()
{
   return score>=60;
}
  
void Student::showInfo()
{
   cout << name << "(" << SID << ") " << score << endl;
}

#include <iostream>
#include "student.h"
using namespace std;

int main()
{
  Student *bob = new Bob;
  bob->showInfo();
  delete bob;
}