Classes

Composition

Composition builds a larger object from smaller objects.

Composition

composition.cpp 
#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}

#include <iostream>
#include <string>

class Battery {
private:
    int charge;

public:
    Battery(int startingCharge) {
        charge = startingCharge;
    }

    void use(int amount) {
        charge -= amount;
    }

    int remaining() {
        return charge;
    }
};

class Robot {
private:
    std::string name;
    Battery battery;

public:
    Robot(std::string robotName, int startingCharge) : name(robotName), battery(startingCharge) {
    }

    void work(int minutes) {
        battery.use(minutes * 2);
    }

    void printStatus() {
        std::cout << "robot=" << name << std::endl;
        std::cout << "charge=" << battery.remaining() << std::endl;
    }
};

int main() {
    std::string robotName = ;
    int minutes = ;

    Robot robot(robotName, 20);
    robot.work(minutes);
    robot.printStatus();
    return 0;
}
composition Composition means one class stores another class as a member field.