オブジェクト内で整数と浮動小数点を正しく使用するにはどうすればよいですか？

Question

私は、次の属性を持つワイナリーのさまざまな属性を追跡するプログラムを作成しようとしています。今年のワイナリーを追跡する

-Dynamically割り当てられたメモリ

-Integersはブドウ畑が取る成功の評価と土地のエーカーのため

-Floatsを開始しました。

- ワイナリーデータの追加、削除、（評価と名前による）表示、保存を行う機能。

私はすでにすべての属性がcstringであった同様のプログラムで動作するコードを作成してデバッグしましたが、このコードは同じフレームワークに基づいています。

私の問題は、動的に割り当てられたcstringsで動作する同じコードが整数または浮動小数点では機能せず、コンパイラから変換エラーメッセージが出ることです。私はlistクラスを持っています。aWineryが含まれています。プライベートメンバーを使ってデータを隠すので、クライアントプログラムからlistとaWineryに渡す関数があります。同じ型の関数は同じですので、ここにはそれぞれの型の関数しか含まれていません。

誰かが間違っていることを指摘できますか？ aWineryのintとfloatの定義がポインタでない場合、どのようにパラメータを返すのか分かりません。私がクラスで見つけることができるダイナミックメモリプログラミングの唯一の例はcstringsを使用しています。私はそれを理解することができなかったので、私はインストラクターからコピーしたコードの2つのポイントに注目しました。

編集：私が得ている具体的なエラーはinvalid conversion from int* to int\n year = this->yearです。aWineryの整数と浮動小数点型のアクセッサ関数とミューテータ関数のすべてで何らかの置換が行われています。

リストアクセッサ、ミューテータ、コンストラクタ、デストラクタ関数

void list::getWineryLocation(char location[]) const 
{ 
    wineryData.getLocation(location); 
} 

void list::getWineryYear(int year) const 
{ 
    wineryData.getYear(year); 
} 

void list::getWineryAcres(float acres) const 
{ 
    wineryData.getAcres(acres); 
} 

void list::setWineryLocation(char location[]) 
{ 
    wineryData.setLocation(location); 
} 

void list::setWineryYear(int year) 
{ 
    wineryData.setYear(year); 
} 

void list::setWineryAcres(float acres) 
{ 
    wineryData.setAcres(acres); 
} 

//Constructor functions 

list::list() 
{ 
    nameHead = NULL; 
    nameTail = NULL; 
    ratingHead = NULL; 
    ratingTail = NULL; 
    size = 0; 
} 

//Destructor 
//Doesn't delete the head/tailRating pointers to avoid double deleting a winery 
list::~list() 
{ 
    node * curr = nameHead; 

    while (nameHead != NULL) 
    { 
     curr = nameHead->nextByName; 

     delete nameHead; 

     nameHead = curr; 
    } 
} 

aWineryアクセッサ、ミューテータ、コンストラクタ、デストラクタ関数

//Winery object constructor 
aWinery::aWinery() 
{ 
    name = new char[strlen("Unknown")+1]; 
    strcpy(name, "Unknown"); 
    location = new char[strlen("Unknown")+1]; 
    strcpy(location, "Unknown"); 
    year = new int; 
    year = 0; 
    acres = new float; 
    acres = 0; 
    successRating = new float; 
    successRating = 0; 
} 

//I have no idea whats going on here 
//Winery destructor 
aWinery::~aWinery() 
{ 
    if(name != NULL) 
     delete [] name; 
    if(location != NULL) 
     delete [] location; 
    if(year != 0) 
     delete year; 
    if(acres != 0) 
     delete acres; 
    if(successRating != 0) 
     delete successRating; 
} 

void aWinery::getLocation(char location[]) const 
{ 
    strcpy(location, this->location); 
} 

void aWinery::getYear(int year) const 
{ 
    year = this->year; 
} 

void aWinery::getAcres(float acres) const 
{ 
    acres = this->acres; 
} 

//I have no idea why this is written this way, I copied this from an instructor example 
void aWinery::setLocation(char location0[]) 
{ 
    if(this->location != NULL) 
     delete [] this->location; 
    this->location = new char[strlen(location0)+1]; 

    strcpy(this->location, location0); 
} 

void aWinery::setYear(int year0) 
{ 
    if(this->year != 0) 
     delete this->year; 
    this->year = new int; 

    this->year = year0; 
} 

void aWinery::setAcres(float acres0) 
{ 
    if(this->acres != 0) 
     delete this->acres; 
    this->acres = new float; 

    this->acres = acres0; 
} 

aWineryヘッダファイル

#ifndef AWINERY_H 
#define AWINERY_H 

#include <iostream> 
using namespace std; 

//winery object 
class aWinery 
{ 
public: 
    //Constructor 
    aWinery(); 

    //Destructor 
    ~aWinery(); 

    //Accessor Prototypes 
    void getName(char name[]) const; 
    void getLocation(char location[]) const; 
    void getYear(int year) const; 
    void getAcres(float acres) const; 
    void getSuccessRating(float successRating) const; 

    //Mutator Prototypes 
    void setName(char name0[]); 
    void setLocation(char location0[]); 
    void setYear(int year0); 
    void setAcres(float acres0); 
    void setSuccessRating(float successRating0); 


private: 
    char* name; 
    char* location; 
    int* year; 
    float* acres; 
    float* successRating; 
}; 

#endif 

リストヘッダファイル

#ifndef ALIST_H 
#define ALIST_H 

#include <iostream> 
using namespace std; 

const int MAX_CHAR_LENGTH = 1000; 

class list 
{ 
public: 
    //Prototypes 
    void setInWinery(char name[], char location[], int year, float acres, float successRating); 
    void initializeDbase(char savePathName[]); 
    void printEntireDbase(); 
    void deleteWinery(char nameOfWinery[]); 
    void whereIsWinery(char nameOfWinery[]); 
    void save(char savePathName[]); 

    //Accessor Prototypes 
    void getWineryName(char name[]) const; 
    void getWineryLocation(char location[]) const; 
    void getWineryYear(int year) const; 
    void getWineryAcres(float acres) const; 
    void getWinerySuccessRating(float successRating) const; 
    int getSize() const; 

    //Mutator Prototypes 
    void setWineryName(char name[]); 
    void setWineryLocation(char location[]); 
    void setWineryYear(int year); 
    void setWineryAcres(float acres); 
    void setWinerySuccessRating(float successRating); 

    //Constructor Prototype 
    list(); 

    //Destructor 
    ~list(); 

private: 
    //Wine object 
    struct node 
    { 
     aWinery wineryData; 
     node * nextByName; 
     node * nextByRating; 
    }; 
    node * nameHead, * nameTail, * ratingHead, * ratingTail; 

    aWinery wineryData; 

    int size; 
}; 

#endif 

Answer 1

私はあなたの問題の大部分は、ここで、ヘッダにあると思う：

private: 
    char* name; 
    char* location; 
    int* year; 
    float* acres; 
    float* successRating; 

これらのメンバ変数のいずれかのポインタを使用する理由は本当にありません。 C++プログラムではありません本当にありますので、私はSTDに（CHAR *）メンバ変数を置き換え

private: 
    std::string name; 
    std::string location; 
    int year; 
    float acres; 
    float successRating; 

注::文字列、：あなたにもそれらをこのようなすべてのプレーンの古い値によるメンバー、なるかもしれません適切な文字列オブジェクトを使用しない理由。（文字列を保持するために動的に割り当てられたchar配列を使うことは、C言語で書いている場合には必要な悪であるかもしれませんが、C++ではマゾヒズムです）

すべてのデータを値ごとに格納することによって、 newとdeleteコマンド（およびそれらに付随する必然的なバグや非効率性）の問題を修正し、必要に応じて値を直接設定して取得するだけです。

また、このアクセサ関数は間違っている：それが原因でC++では動作しません

void aWinery::getYear(int year) const 
{ 
    year = this->year; 
} 

、メソッドのパラメータは、（デフォルトで）値によって渡されます（つまり、渡された値の一時的なローカルコピーメソッドが使用されるために作成されます）、上記のメソッドはすべてローカルパラメータyearを変更します。この関数は、関数が返されるとただちに破棄されます。 ....

int aWinery::getYear() const 
{ 
    return this->year; // assuming year member variable is now of type int 
} 

を、同様に、setterメソッドは次のようになります：適切なアクセサメソッドは、より次のようになり

void aWinery::setYear(int newYear) 
{ 
    this->year = newYear; // assuming year member variable is now of type int 
}