我可以点一个派生类不同的基地？ （即：改变一个孩子的家庭）

问题描述 投票：-4回答：3

我在写一些演习代号理解类的继承，我无法弄清楚。如果有一种方法做什么，我试图在标题来解释。

因此，我想要做的有家庭和成员（家庭成员）类。一个家庭可以有多个成员，但成员只能有一个家庭。但是，假设其中一个成员结婚。因此，他们是从其他家庭B.改变他们的家人有没有办法做到这一点？

#include <iostream>
#include <string>

class Family {
    std::string _familyName;
public:
    Family();
    void setFamilyName(std::string& str) { _familyName = str;}
    void printFamilyName() {
        std::cout << "Family name is: " << _familyName << std::endl;
    }
}

class Member : public Family {
    std::string _firstName;
public:
    Member();
    void setFirstName(std::string& str) { _firstName = str;}
    void changeFamily(Family *f) {} // What do i do here ?

}

int main(){
    Member m;
    m.setFamilyName("Smith");
    m.setFirstName("John");
    m.printFamilyName();
    Family f;
    B.setFamilyName("Williams");
    m.changeFamily(&f);
    m.printFamilyName();
    return 0;
}

由此，我想获得一个输出

Family name is: Smith
Family name is: Williams

谢谢。

（一个额外的问题是，有没有一种方法来创建一个成员变量，无需构建家庭的一部分，但对新成员varible绑定到现有家庭变量同时声明会员吗？）

c++ derived-class
3个回答
0
投票

我不认为你需要继承，你认为什么是继承是不正确的。当有多个类一起工作的工作要么是包含另一种或父子关系一类，总有一个问题要问自己：这两个类之间的关系是一种“有关系”或者是“有关系”。当你问自己这个问题，这是很容易回答的问题，那么你应该知道什么设计键入您的类将需要。

例如：狗是哺乳动物，狗有爪子。因此，如果我们有3个班在这里。该结构将是这个样子：

class Mammal {
    /* code */
};

class Dog : public Mammal {
    /* code */
};

在这里，我们有继承，因为狗是哺乳动物，且将继承所有的特质，所有的哺乳动物有！

下一步，我们将有这样的：

class Paws {
    /* code */
};

因此，让我们回到我们的“狗”类

class Dog : public Mammal {
private:
    Paws paws; // this is a member of Dog because a Dog HAS PAWS!
};

我希望这将清除的东西了类的基本结构！

现在回头看看你最初的问题，这里是我做了什么。我做了一个基本的结构来表示FamilyMember，他们都对自己在共同彼此相同的信息。我抽象出来的姓氏完全删除任何依赖关系，并有检查，如果姓是一样的，并更新或更换等我的代码如下所示：

struct FamilyMember {
    std::string firstName_;
    unsigned int age_;
    char gender_;

    FamilyMember() = default;
    FamilyMember(const std::string& firstName, unsigned int age, char gender) :
        firstName_(firstName),
        age_(age),
        gender_(gender)
    {}
};

class Family {
private:
    std::string familyName_;
    std::vector<FamilyMember> members_;

public:
    Family() = default;
    explicit Family(const std::string& familyName) : familyName_( familyName ) {
    }

    void addMember(FamilyMember& member) {
        members_.push_back(member); 
    }

    FamilyMember& getMember(unsigned int idx) {
        return members_.at(idx);
    }

    std::vector<FamilyMember>& getFamily() {
        return members_;
    }

    const std::string& getFamilyName() const { return familyName_; }
};

int main() {
    Family Smith("Smith");
    FamilyMember John("John", 32, 'M');
    FamilyMember Sarah("Sarah", 29, 'F');
    FamilyMember Amanda("Amanda", 19, 'F');
    Smith.addMember(John);
    Smith.addMember(Sarah);
    Smith.addMember(Amanda);

    std::cout << "Meet the " << Smith.getFamilyName() << "s:\n";
    for (auto& m : Smith.getFamily()) {
        std::cout << m.firstName_ << " " << Smith.getFamilyName() << " " << m.age_ << " " << m.gender_ << '\n';
    }

    Family Jones("Jones");
    FamilyMember Tom("Tom", 44, 'M');
    FamilyMember Mary("Mary", 43, 'F');
    FamilyMember Mike("Mike", 21, 'M');
    Jones.addMember(Tom);
    Jones.addMember(Mary);
    Jones.addMember(Mike);

    std::cout << "Meet the " << Jones.getFamilyName() << "s:\n";
    for (auto& m : Jones.getFamily() ) {
        std::cout << m.firstName_ << " " << Jones.getFamilyName() << " " << m.age_ << " " << m.gender_ << '\n';
    }

    std::cout << "We present to you today the Union between: "
        << Jones.getMember(2).firstName_ << " " << Jones.getFamilyName() << " and "
        << Smith.getMember(2).firstName_ << " " << Smith.getFamilyName() << '\n';

    Jones.addMember(Amanda);
    std::cout << "We now have Mr. " << Jones.getMember(2).firstName_ << " " << Jones.getFamilyName() << " and "
        << "Mrs. " << Jones.getMember(3).firstName_ << " " << Smith.getFamilyName() << " " << Jones.getFamilyName() << '\n';    

    return 0;
}

所以你可以从上面的小程序见;我们不必为在所有修改姓氏的依赖。利用这种结构，当“阿曼达”结婚“迈克”。她仍然属于“史密斯”的家庭，但她也加入了与“琼斯”系列。现在，如果你试图通过结构来访问她的个人数据，也没有关于她的姓氏信息。你可以找回她的名字，年龄和性别。如果你想为姓的信息，你必须检索从家庭类本身，因为它永远不会改变！

1
投票

一个家庭可以有多个成员，但成员只能有一个家庭。但是，假设其中一个成员结婚。因此，他们是从其他家庭B.改变他们的家人有没有办法做到这一点？

你需要的对象，而不是对象类型之间定义的关系。派生类之间的阶级关系 - 您可以通过使用对象之间的包含容器的关系，而不是一个基类做到这一点。

struct Member;
struct Family
{
   std::vector<Member*> members;
}

struct Member
{
   Family* family;
}

我会让你知道如何定义类的成员函数使物体和物体的寿命之间的关系保持在一个稳健的方式。

0
投票

简短的回答：没有。继承是在编译时设置，不能在运行时改变它。

但我不认为遗传是你在找什么。 Member继承所有成员和Family的功能。这并不意味着Member和Family的任何特定实例之间的关系。这反映在您的设计 - _familyName是一个字符串，而不是一个对象或东西的参考。但是你可以对其他对象的引用。例如，像这样：

#include <iostream>
#include <string>
#include <vector>

class Family {
    std::string _familyName;
public:
    Family(std::string name) : _familyName(name) {};
    void printFamilyName() {
        std::cout << "Family name is: " << _familyName << std::endl;
    }
}

class Member {
    std::string _firstName;
    std::vector<Family*> families;
public:
    Member(Family *familyPtr) { addFamily(familyPtr) };
    void setFirstName(std::string& str) { _firstName = str;}
    void addFamily(Family *familyPtr) { families.push_back(familyPtr) };
    void printFamilies() { for (auto &ptr : families) { ptr->printFamilyName() } };
}

int main()
{
    Family Jackson("Jackson");
    Family Williams("Williams");
    Member John(&Jackson);
    Member Alice(&Williams);
    John.printFamilies();
    John.addFamily(&Williams);
    John.printFamilies();
    return 0;
}

Member不需要任何的功能或类Family的价值，所以我们没有继承他们。相反，我们维持指针列表来Family对象，这Member“属于”，从而暗示该Member和Family这些实例之间的关系。当我们要打印的所有对象Family是Member拥有，我们只是循环通过指针的载体，并呼吁printFamilyName()对他们每个人。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.