使用构造函数初始化类中的指针[重复]

Question

我在“album.h”中有一个Album 类，如下所示：

#include "song.h"

class Album
{
public:
Album(string _id, string _title, string _singer, float _price, vector<Song> _songs) : id(_id), title(_title), singer(_singer), price(_price), songs(_songs), availableAlbums(10) {}
void add_song(Song s){ songs.push_back(s); }
void add_availableAlbums(int added){ availableAlbums += added; }
string get_id(){ return id; }
string get_singer(){return singer;}

private:
string id;
string title;
string singer;
float price;
vector <Song> songs;
int availableAlbums;
};

和“song.h”中的Song 类，如下所示：

#include "album.h"

class Song
{
public:
Song(string _numOfSong, string _title, string _singer, string _duration, float _price): 
numOfSong(_numOfSong), title(_title), singer(_singer), duration(_duration), price(_price){}

private:
string numOfSong;
string title;
string singer;
string duration;
float price;
Album* album;
};

我们知道每个Song 都有一个Album（每个Song 必须指向它的Album），我通过为每个Song 初始化一个Album* 来做到这一点，我有一些错误是这里：

error C2061: syntax error : identifier 'Album'
error C2065: '_album' : undeclared identifier
error C2143: syntax error : missing ';' before '*'
error C2614: 'Song' : illegal member initialization: 'album' is not a base or member
error C4430: missing type specifier - int assumed. Note: C++ does not support default-int

谢谢

Answer 1

代码是正确的，您只需确保Album 实例在Song 实例的生命周期内存在。 如果Song::album 指针没有改变，那么使用引用可能会更干净。这意味着album在构建后不能指向另一个专辑。

class Song {
public:
    Song(Album& _album) : album(_album) { }
private:
    Album& album;
}

但是Song不能被默认operator=分配。需要重载检查其他Song的相册是否相同，只分配其他属性。

如果Song 不修改Album 对象，则可以通过使用const Album*（或const Album&）同时作为成员变量类型和构造参数来强制执行常量正确性。

如果Album对象的生命周期不是手动控制的，你可以使用std::shared_ptr<Album>。

Answer 2

好吧，由于我的声誉，我无法发表评论，所以我写了一个答案

你的Song 类有一个构造函数，它接受一个指向Album 类的指针，所以假设你有以下代码：

Album* album = new Album();
Song song = new Song(album);

在第一行你创建一个新专辑，在第二行你用最近创建的专辑创建一首新歌。

Album* album1 = song->album; // This is how you can access song's album

但是，请注意，每当您使用 new 创建对象时，您应该在使用完该对象以释放用于该对象的内存时使用 delete 关键字。

所以，您的代码没有问题，或者至少我找不到任何问题。