理解OOP协会和函数（C++）

Question

目前仍然的东西整个负载我不理解在C对象和类++，没有到目前为止，我已阅读使我更懂得它的任何和我一起慢慢拼凑信息从我设法完成的练习中。

很少要点： 当从一个类创建一个对象时，如何访问另一个类中的函数中的对象的名称？什么类型的变量是存储在对象中的名称？它创建后甚至存储在任何地方？

我的手册具有产生两个类之间的关联的例子;

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

这实际上是什么意思？ Aggregationclass可以访问partclass中的对象partobject？什么变量可以从partclass中通过聚合类读取？

这是我从我的C++面向对象introductionary类，是希望我利用级别之间的关联卡上的锻炼。 （7（2/2）/ 11）

它包括不可编辑的汽车类;

#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; 
} 

免责声明：运动已经从译成另一种语言，在发现我没有注意到一个翻译错误的情况下，请不要发出通知，我会尽我所能来解决。

成品锻炼;谢谢你，博士爱好者花时间回复你，我可以自信地说，我学到了很多东西！

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_; 
}; 

你不能从外部获取到私人的东西。期。 您可以（或构建）一个

Car car("Zoom", 42); 

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

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

很明显它可以节省掉串，并在私有成员变量make_和driven_km_诠释。

现在，我们可以调用这个实例的公共职能：

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

所以，我们已经取得了一辆汽车，并呼吁一些功能。

我们也可以制作汽车指针并调用它的功能。我们需要删除东西，否则我们会泄漏。

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

现在你的问题。

你已经开始写一个Person类，它有两个（私人）汽车（指针）make_和driven_km_。构造函数Person(string, string);需要两个字符串，但主要不发送两个字符串：

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); 

从这里开始，在主，你可以叫

dx->PrintDrivenKm(); 

从人的构造函数中，

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

你可以叫上车的方法（或car_）在大括号内：

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

注意：Car::意味着类/ structr/namespace/scope Car中的某些东西 - 但是您希望调用实例方法，所以需要一个实例名称。使用->指向实例的指针上的所有方法。使用.来调用实例上的方法。