理解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中的某些東西 - 但是您希望調用實例方法，所以需要一個實例名稱。使用->指向實例的指針上的所有方法。使用.來調用實例上的方法。