C++中的指针数组

Posted 2023-02-21

【中文标题】C++中的指针数组

【英文标题】：Array of Pointers in C++

【发布时间】：2015-12-07 22:58:06

【问题描述】：

我正在尝试为我的 c++ 类编写一些代码。我正在使用日食。我很难理解问题中的一些说明。

我创建了一个名为 Ship 的基类，然后为我的 CruiseShip 类和 CargoShip 类使用继承。

对于 CruiseShip 类，我被指示创建

重写基类中的打印函数的打印函数。游轮 类的打印功能应该只显示船名和最大数量 乘客人数。

对于 CargoShip 类也是如此

重写基类中的打印函数的打印函数。货船 类的打印功能应该只显示船名和船的载货量。

我不确定在基类中“覆盖”打印函数意味着什么。

它还告诉我要这样做

演示具有 Ship 指针数组的程序中的类。数组 元素应该使用动态分配的 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;

【问题讨论】：

"我使用 eclipse 作为我的编译器。" Eclipse 是 IDE，而不是编译器。

@MrEricSir 的意思是你应该在谷歌上搜索“虚拟函数 c++”和“基类指针多态 c++”大多数人不会在这里帮助你 b/c 你没有表现出任何努力研究问题。

我不知道。我会编辑我的问题...@MrEricSir

@TriHard8 感谢您为我指明正确的方向。

二传手轻松！你永远不需要set_year，因为构建年份永远不会改变。 set_capacity 同样极不可能被需要。

【参考方案1】：

假设您有以下课程：

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

如果您在堆栈上创建一个数组（没有 new），您要么必须使用字面量 (0, 1, 2, ...) 或使用 const int variableName 对其大小进行硬编码。这样，编译器在编译时就知道数组大小。所以你在编写程序时必须知道数组的大小。因此，编译器不允许您这样做：std::cin >> size;。

使用新的（动态数组），您可以在编译时指定数组大小。因此，让您的程序计算数组大小或将其作为用户输入是合法的。与使用小堆栈 (***) 相比，使用动态数组还有很多很多很多的内存。

int *array: 显然内存内容被解释为整数。 *array 指向数组的第一个元素。 int *array 不知道数组的大小。您必须自己跟踪。

new int[size]: 你在堆上为 size * 个整数保留空间。

您可能知道 C++ 没有垃圾收集器。这就是delete[] array; 发挥作用的时候。当您不再需要array（这包括其他指向array 的指针）时，您应该调用delete 来释放内存。对于小而短的运行程序，忘记它并不重要，因为操作系统（操作系统）会在程序终止后释放内存。尽管如此，你应该使用delete，因为不使用它仍然很糟糕，并且会导致更大的程序出现问题。如果在类中使用array，则应将delete 放在类的析构函数中（~clasname()）。