在C + +指針陣列

Question

我想爲我的c + +類寫一些代碼。我正在使用eclipse。我很難理解問題中的一些說明。

我創建了一個名爲Ship的基類，然後爲我的CruiseShip類和CargoShip類使用了繼承。

對於遊輪類，我奉命創建

，它覆蓋在基類中的打印功能打印功能。 CruiseShip 班級的打印功能應只顯示船名和乘客的最大號碼 。

並且類似地對於CargoShip類

重寫在基類的打印功能的打印功能。班級的打印功能應該只顯示船名和船的貨物容量。

我不確定在基類中「覆蓋」打印函數意味着什麼。

它也指示我

證明有船舶指針數組程序的類。數組 元素應使用動態分配的Ship， CruiseShip和CargoShip對象的地址進行初始化。然後程序應該遍歷數組，每個對象的打印函數調用 。

#include <iostream> 
#include <string> 
using namespace std; 

class Ship 
{ 
protected: 
    string ship_name; 
    int year_built; 
public: 
    Ship() 
    { 
     ship_name=""; 
     year_built=0; 
    } 
    void set_ship_name(string str) 
    { 
     ship_name=str; 
    } 
    void set_year(int y) 
    { 
     year_built=y; 
    } 
    int get_year() 
    { 
      return year_built; 
    } 
    string get_ship_name() 
    { 
      return ship_name; 
    } 

    void print(string, int) 
    { 
      cout<<"Ship name is "<<ship_name<<" and it was built in the year "<<year_built<<endl; 
    } 
}; 

class CruiseShip: public Ship 
{ 
private: 
    int max_passengers; 
public: 
    CruiseShip()// :Ship(str,year) 
    { 
    max_passengers=0; 
    } 
    void set_passengers(int pass) 
    { 
      max_passengers=pass; 
    } 
    int get_passengers() 
    { 
      return max_passengers; 
    } 
    void print1(string, int) 
    { 
      cout<<"Ship name is "<<get_ship_name()<<" and max number of passengers are "<<max_passengers<<endl; 
    } 

}; 

class CargoShip: public Ship 
{ 
private: 
    int cargo_capacity_in_tons; 
public: 
    CargoShip()//:Ship (str,year) 
    { 
     cargo_capacity_in_tons=0; 
    } 
    void set_capacity(int pass) 
    { 
     cargo_capacity_in_tons=pass; 
    } 
    int get_capacity() 
    { 
      return cargo_capacity_in_tons; 
    } 
    void print2(string, int) 
    { 
      cout<<"Ship name is "<<get_ship_name()<<" and its capacity is "<<cargo_capacity_in_tons<<" Tons."<<endl; 
    } 
}; 

int main(){ 
CruiseShip ship1; 
CargoShip ship2; 

string ship_name1; 
string ship_name2; 
int year_built1; 
int year_built2; 
int max_passengers; 
int cargo_capacity_in_tons; 

cout<<"What is the name of the cruise ship?"<<endl; 
cin>>ship_name1; 
ship1.set_ship_name(ship_name1); 

cout<<"What year was "<<ship_name1<<" built in?"<<endl; 
cin>>year_built1; 
ship1.set_year(year_built1); 


cout<<"What is the maximum capacity of "<<ship_name1<<"?"<<endl; 
cin>>max_passengers; 
ship1.set_passengers(max_passengers); 

//ship1.print(ship_name1, year_built1); 
ship1.print1(ship_name1, max_passengers); 

cout<<"What is the name of the cargo ship?"<<endl; 
cin>>ship_name2; 
ship2.set_ship_name(ship_name2); 

cout<<"What year was "<<ship_name2<<" built in?"<<endl; 
cin>>year_built2; 
ship2.set_year(year_built2); 

cout<<"What is the maximum capacity of "<<ship_name2<<" in tons?"<<endl; 
cin>>cargo_capacity_in_tons; 
ship2.set_capacity(cargo_capacity_in_tons); 

ship2.print2(ship_name2, cargo_capacity_in_tons); 


return 0; 
} 

Answer 1

Let's說，你有以下類：

class Animal 
{ 
private: 
    int x; 
    int y; 
public: 
    virtual string sound() {return "Animal";} 
    void move() {x += 1; y+=1;} 
}; 

class Cow 
{ 
    string sound() {return "Muh"} //this is overriding 
    string sound(string soundYouWant) {return soundYouWant;} //this is not overriding as string sound(string soundYouWant) is not the same as string sound() 
    void move() {x += 1; y+=1;} //this is also not overriding as move() in Animal has no virtual 
}; 

所以總結一下，壓倒一切意味着你必須在基類虛方法和派生你重新聲明它類。這樣，您可以爲每個派生類重新定義它（對於基類及其派生類，方法體可以不同）。

我們動態分配數組：

int size; 
std::cin >> size; 
int *array = new int[size]; //the array is stored on the heap 
delete[] array; //deallocates the array and so frees the memory 

如果在棧上創建的陣列（沒有新的），則要麼必須硬編碼其使用尺寸的文字（0，1，2，...）或使用const int variableName。這樣，編譯器在編譯期間知道數組的大小。所以在編寫程序時你必須知道數組的大小。因此，編譯器不會允許你這樣做：std::cin >> size;。

使用新的（動態數組），您可以在編譯時指定數組大小。因此，讓程序計算數組大小或將其作爲用戶輸入是合法的。有了動態數組，你也有很多很多，比使用小堆棧（stackoverflow）更多的內存。

int *array：顯然內存內容被解釋爲整數。 *array指向數組的第一個元素。 int *array不知道數組的大小。你必須自己跟蹤。

new int[size]：您正在爲堆上的大小*整數保留空間。

您可能知道C++沒有垃圾收集器。這是delete[] array;發揮作用。當您不再需要array（這包括指向array的其他指針）時，應該撥打delete來釋放內存。對於小型，短時間運行的程序，忘記它無關緊要，因爲操作系統會在程序終止後釋放內存。不過，你應該使用delete作爲不使用它仍然很糟糕，並會導致更大的程序的麻煩。如果在班級中使用array，則應將delete放在班級的分解器（~clasname()）中。