c++ - 了解 OOP 关联和函数 (c++)

Question

关于 C++ 中的对象和类，仍然有一大堆我不理解的东西，到目前为止我所读的任何东西都没有帮助我理解其中的任何东西，我正在慢慢地将我设法完成的练习中的信息拼凑在一起。

几个要点:当一个对象是从一个类创建的，你怎么能在另一个类的函数中访问这个对象的名字呢？对象名称存储在什么类型的变量中？它在创建后是否存储在任何地方？

我的手册中有一个在两个类之间创建关联的示例；

    Aggregationclass
{
public:
  ...
private:
  Partclass* partobject_;
  ...
};

这到底是什么意思？聚合类可以访问partclass中的对象partobject吗？ aggregationclass可以从partclass中读取哪些变量？

这是我在 c++ OOP 入门类(class)中遇到的一个练习，它要求我利用类之间的关联。 (7(2/2)/11)

它由不可编辑的Car类组成；

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

class Car
{
public:
    void Move(int km);
    void PrintDrivenKm();
    Car(string make, int driven_km);
private:
    string make_;
    int driven_km_;
};

Car::Car(string make, int driven_km) : make_(make), driven_km_(driven_km)
{
}

void Car::Move(int km)
{
    driven_km_ = driven_km_ + km;
    cout << "Wroom..." << km << " kilometers driven." << endl;
}
void Car::PrintDrivenKm()
{
    cout << make_ << " car has been driven for" << driven_km_ << " km" << endl;
}

到目前为止我做了什么(Person类)；我在这部分的评论中写下了我的大部分问题。

class Person //how do I associate Person class with Car class in a way that makes sense?
{
    public:
    void ChangeCar(string);
        Person(string, string);
    int DriveCar(int);

    private:
    Car* make_;         
    Car* driven_km_;

    string name_;
};

Person::Person(string name, string make) //How do I ensure string make == object created from class Car with same name?
{
    Person::name_ = name;
    Car::make_ = make_;
}
int Person::DriveCar(int x) //Is this the correct way to use a function from another class?
{
    Car::Move(x);
}
void Person::ChangeCar(string y) //this function is wrong, how do I create a function that calls for object from another class with the parameter presented in the call for this function (eg. class1 object(ferrari) = class1 object holds the values of object ferrari from class2?)?
{
    Car::make_ = y;
}

和不可编辑的 main();

int main()
{
    Car* dx = new Car("Toyota corolla DX", 25000);
    Car* ferrari = new Car("Ferrari f50", 1500);

    Person* driver = new Person("James", dx);

    dx->PrintDrivenKm();
    driver->DriveCar(1000);
    dx->PrintDrivenKm();

    ferrari->PrintDrivenKm();
    driver->ChangeCar(ferrari);
    driver->DriveCar(20000);
    ferrari->PrintDrivenKm();
    return 0;
}

免责声明:该练习已从另一种语言翻译而来，如果发现我没有注意到的翻译错误，请务必通知我，我会尽力修复。

完成练习；谢谢你/doctorlove 花时间回复，我可以自信地说我学到了很多东西!

    class Person
{
public:
void ChangeCar(Car * y);
    Person(String name, Car * Car);
int DriveCar(int);
private:
Car * Car_;
int x;
string name_;
string y;
};

Person::Person(string name, Car * Car) : name_(name), Car_(Car)
{
  Person::name_ = name;
}
int Person::DriveCar(int x)
{
  Car_->Move(x);
}
void Person::ChangeCar(Car * y)
{
 Car_ = y;
}

Answer 1

在讲指针之前，先看Car类:

class Car
{
public:
    void Move(int km);
    void PrintDrivenKm();
    Car(string make, int driven_km);
private:
    string make_;
    int driven_km_;
};

你不能从外面得到私有(private)的东西。时期。你可以制作(或 build )一个

Car car("Zoom", 42);

因为我们可以看到构造函数做了什么

Car::Car(string make, int driven_km) : make_(make), driven_km_(driven_km)
{
}

很明显，它在私有(private)成员变量make_和driven_km_中保存了string和int。

现在我们可以在这个实例上调用公共(public)函数:

car.PrintDrivenKm();
car.Move(101);
car.PrintDrivenKm();

所以，我们制造了一辆汽车并调用了一些功能。

我们可以制作一个汽车指针并调用它的函数。我们需要删除内容，否则我们会泄漏。

Car * car = new Car("Zoom", 42);
car->PrintDrivenKm();
car->Move(101);
car->PrintDrivenKm();
delete car;

现在解决您的问题。

您已经开始编写一个 Person 类，它有两辆(私有(private))汽车(指针)make_ 和 driven_km_。构造函数 Person(string, string); 接受两个字符串，但 main 不向它发送两个字符串:

Car* dx = new Car("Toyota corolla DX", 25000);
// ...
Person* driver = new Person("James", dx);

它会被发送一个字符串和一个Car *;像这样

Person(string name, Car *car);

所以也许它只需要一辆车(指针)，Car *car_？

现在至于调用汽车指针，Car 有Move 方法；实例方法不是静态方法，因此在实例上调用它:

int Person::DriveCar(int x)
{
    //Car::Move(x);  //no - which car do we move, not a static on ALL cars
    car_->Move(x);
}

现在，如果这个人想换车，你让他拿一根绳子:

void Person::ChangeCar(string y)
{
    //what goes here?
    // you want a Car * from a string...
    //  we did that before
    delete car_; //not exception safe, but ... 
    car_ = new Car(y);
}

回头看面:

driver->ChangeCar(ferrari);

因此调用代码将尝试发送汽车(指针)以交换到。所以，得到正确的签名:

void Person::ChangeCar(Car * y)
{
    car_ = y;
}

如果您拥有指针，则需要一个析构函数来整理指针。告诉在 main 中编写代码的人删除他们的指针!

---

编辑:

重申一下，在任何 Person 中，您都可以调用 meber 变量 car_ 函数的方法，例如

void Person::ChangeCar(Car * y)
{
    car_ = y;
    y->PrintDriveKm(); //call a method on a car pointer.
    car_->PrintDriveKm();
}

这与在我的答案顶部附近提到的在指针上调用方法完全相同。

回到

Car* dx = new Car("Toyota corolla DX", 25000);
// ...
Person* driver = new Person("James", dx);

从这里，在 main 中，你可以调用

dx->PrintDrivenKm();

从 Person 构造函数内部，

Person(string name, Car *car) : name_(name), car_(car)
{
}

您可以在大括号内调用 car(或 car_)上的方法:

Person(string name, Car *car) : name_(name), car_(car)
{
     std::cout << "Hello, " << name << '\n';
     car_->PrintDrivenKm();
}

注意:Car:: 表示类/structr/命名空间/范围 Car 中的内容 - 但您想要调用实例方法，因此需要一个实例名称。将 -> 用于实例指针上的所有方法。使用 . 在实例上调用方法。