C++ 将一组对象传递给抽象的成员函数 class

Question

我想将对象传递给 class 的成员函数并从中执行一些函数。当我使用 *myCars 指针执行此操作时，一切正常。但是，当我尝试将其传递给纯虚拟 class 时，程序会出现 returns 错误（请参阅解决方案 A）。我有一个临时解决方案（参见解决方案 B），但它对我来说似乎不合适。有解决办法吗？

main.cpp

#include <iostream>
#include "car.h"
#include "veicles.h"
#include "traffic.h"

int main(){

        int number = 3;
        Car *myCars = new Car[number];

        Traffic mtc;
        mtc.import(myCars, number);

        Veicles *myVeicles = new Car[number];

//      Solution A
//      Traffic mtvA;
//      mtvA.import(myVeicles, number);

//      Solution B
        std::cout << "\nsolution B\n";
        Traffic mtvB;
        mtvB.import(&myVeicles, number);

        delete[] myCars;
        delete[] myVeicles;

        return 0;
}

car.h

#ifndef CAR_H
#define CAR_H

#include <iostream>
#include "veicles.h"

class Car : public Veicles{
public:
    void move();

};

#endif

car.cpp

#include "car.h"

void Car::move(){

        std::cout << "the car is moving\n";
}

traffic.h

#ifndef TRAFFIC_H
#define TRAFFIC_H

#include "car.h"

class Traffic{
public:

    void import(Car p[], int number);
    void import(Veicles *v[], int number);
private:

    Veicles *vc;

};

#endif

traffic.cpp

#include "traffic.h"
#include "car.h"

void Traffic::import(Car p[], int number){

        for(int i = 0; i < number; i++){
                p[i].move();
        }
} 

void Traffic::import(Veicles *v[], int number){

        vc = *v; 
        for(int i = 0; i < number; i++){
               // vc -> move();
               vc[i].move(); //  EDIT: R Sahu sugestion
        }
}

veicles.h

#ifndef VEICLES_H
#define VEICLES_H

class Veicles{
public:

    virtual void move() = 0;
};

#endif

veicles.cpp

#include "veicles.h"

// some stuffs to do latter..

生成文件

all:    clean car veicles traffic main
        g++ car.o traffic.o main.o -o main.out
run:
        ./main.out

car:    car.h
        g++ -c car.cpp -o car.o

veicles: car.h veicles.h
        g++ -c veicles.cpp -o veicles.o

traffic: traffic.h car.h
        g++ -c traffic.cpp -o traffic.o


main: traffic.h car.h
        g++ -c main.cpp -o main.o

clean:
        rm -f *.o
        rm -f *.gch

Answer 1

  void import(Car p[], int number);

与

相同

  void import(Car* p, int number);

您不能使用 Vehicle* 类型的参数调用它，因为基 class 指针不能自动转换为派生 class 指针。

假设你有：

class Truck : public Veicles{
 ...
};

和

Veicles *myVeicles = new Truck[number];

如果编译器允许您调用该函数，您将突然能够在需要 Car 的地方使用 Truck。那会导致灾难。

以下函数有效

void Traffic::import(Veicles *v[], int number){
   vc = *v; 
   for(int i = 0; i < number; i++){
      vc -> move();
   }
}

但是，请注意您没有使用 i 来访问 vc 的元素。您仅在第一个对象上调用 move()。

下面就是问题了

void Traffic::import(Veicles *v[], int number){
   vc = *v; 
   for(int i = 0; i < number; i++){
      vc[i].move();
   }
}

原因是您不能将派生 class 对象的数组视为基础 class 对象的数组。

C++ 将一组对象传递给抽象的成员函数 class

C++ Passing a set of objects to a member functions of abstract class

c++

object

inheritance

abstract

pure-virtual