将值传递给其他类

Question

I have to code two classes, a class that allows the user to store the weight of a lollipop:

    #include "Lollipop.h"

Lollipop::Lollipop()
{
    this->weight = 0.0; //weight in grams
}

Lollipop::Lollipop(const Lollipop & aWeight)
{
    this->weight = aWeight.weight;
}


Lollipop::~Lollipop()
{
}

Lollipop & Lollipop::operator=(const Lollipop & aWeight)
{
    this->weight = aWeight.weight;
    return(*this);
}

void Lollipop::changeWeight()
{
    cout << "\n\nPlease input the lollipop's weight: ";
    cin >> this->weight;
    while (this->weight <= 0)
    {
        cout << "\n\nThe input is invalid, please try again with a number greater than 0..."
            "\n\nPlease input the lollipop's weight: ";
        cin >> this->weight;
    }
}

double Lollipop::getWeight()
{
    return (this->weight);
}

void Lollipop::showWeight() const
{
    cout << "This is the weight of the lollipop: " << this->weight << "g" << endl;
}

bool Lollipop::equalW(const Lollipop & aWeight) const
{
    cout << "The lollipops are of equal weight.";
    return (this->weight == aWeight.weight);
}

bool Lollipop::notEqualW(const Lollipop & aWeight) const
{
    cout << "The lollipops are not of equal weight.";
    return (this->weight != aWeight.weight);
}

ostream & operator<<(ostream& out, const Lollipop & aWeight)
{
    out << aWeight.weight;
    return(out);
}

istream & operator>>(istream & in, Lollipop & aWeight)
{
    in >> aWeight.weight;
    return(in);
}

bool Lollipop::operator==(const Lollipop& aWeight) const
{
    return (this->weight == aWeight.weight);
}

bool Lollipop::operator==(bool Assign) const
{
    return (this->weight == Assign);
}

bool operator==(double value, const Lollipop& aWeight)
{
    return (value == aWeight.weight);
}

bool Lollipop::operator!=(const Lollipop& aWeight) const
{
    return (this->weight != aWeight.weight);
}

bool Lollipop::operator!=(bool Assign) const
{
    return (this->weight != Assign);
}

bool operator!=(double value, const Lollipop& aWeight)
{
    return (value != aWeight.weight);
}

And another that will take the weight of those lollipops and store them in a bag, to then add the weight all together. It will then allow the user to compare the weight of two bags. How would I go on about sharing the weight from one class to another?

Answer 1

• Lollipop 's getWeight method should be public. You can make Lollipop a struct, so all the members and methods are public by default, or a class, in which case you explicitly have to declare what parts of the class are public.
• You could create a LollipopBag struct/class having a private std::vector<Lollipop> bag member to store the lollipops.
• LollipopBag should define some methods to allow a user to add lollipops to the bag and calculate the total weight, at least.

class LollipopBag
{
public:
    LollipopBag() = default;
    LollipopBag(size_t n) : bag(n) {}    
    Lollipop& operator[](size_t i) { return bag[i]; }
    const Lollipop& operator[](size_t i) const { return bag[i]; }
    size_t size() const { return bag.size(); }
    void add(const Lollipop& lollipop) { bag.push_back(lollipop); }
    double weight() const { return std::accumulate(std::begin(bag), std::end(bag), 0.0,
        [](auto total, const auto& b) { return total + b.getWeight(); }); }
private:
    std::vector<Lollipop> bag{};
};

int main()
{
    // Option 1
    {
        LollipopBag bag{3};  // creating a bag with 3 lollipops
        for (size_t i{0}; i < bag.size(); ++i)  // for each element in the bag
        {
            auto& lollipop{ bag[i] };
            lollipop.changeWeight();  // change the weight of the lollipop using changeWeight
        }
        std::cout << "\n\n[1] Bag weight: " << bag.weight();
    }

    // Option 2
    {
        LollipopBag bag{};  // creating an empty bag of lollipops
        for (auto&& weight : { 4.0, 5.0, 6.0 })
        {
            bag.add(Lollipop{weight});  // add 3 lollipops using a constructor accepting a double
        }
        std::cout << "\n\n[2] Bag weight: " << bag.weight();
    }
}

// Outputs:
//
//   [1] Bag weight: 6
//
//   [2] Bag weight: 15

• For the option 2 above to work, I've added an explicit Lollipop(double w) constructor, so that you can create a lollipop simply from a double. Otherwise, you'd have to create an empty one and the give it a value through changeWeight .

explicit Lollipop(double w) : weight{w} {}

[Demo]