Language Selector

10.2 — Composition

In real-life, complex objects are often built from smaller, simpler objects. For example, a car is built using a metal frame, an engine, some tires, a transmission, a steering wheel, and a large number of other parts. A personal computer is built from a CPU, a motherboard, some memory, etc… Even you are built from smaller parts: you have a head, a body, some legs, arms, and so on. This process of building complex objects from simpler ones is called composition (also known as object composition).

More specifically, composition is used for objects that have a has-a relationship to each other. A car has-a metal frame, has-an engine, and has-a transmission. A personal computer has-a CPU, a motherboard, and other components. You have-a head, a body, some limbs.

So far, all of the classes we have used in our examples have had member variables that are built-in data types (eg. int, double). While this is generally sufficient for designing and implementing small, simple classes, it quickly becomes burdensome for more complex classes, especially those built from many sub-parts. In order to facilitate the building of complex classes from simpler ones, C++ allows us to do object composition in a very simple way -- by using classes as member variables in other classes.

Lets take a look at some examples of how this is done. If we were designing a personal computer class, we might do it like this (assuming we’d already written a CPU, Motherboard, and RAM class):

Initializing class member variables

In the previous lesson on initializer lists, you learned that the preferred way to initialize class members is through initializer lists rather than assignment. So let’s write a constructor for our PersonalComputer class that uses an initialization list to initialize the member variables. This constructor will take 3 parameters: a CPU speed, a motherboard model, and a RAM size, which it will then pass to the respective member variables when they are constructed.

Now, when a PersonalComputer object is instantiated using this constructor, that PersonalComputer object will contain a CPU object initialized with nCPUSpeed, a Motherboard object initialized with strMotherboardModel, and a RAM object initialized with nRAMSize.

It is worth explicitly noting that composition implies ownership between the complex class and any subclasses. When the complex class is created, the subclasses are created. When the complex class is destroyed, the subclasses are similarly destroyed.

A full example

While the above example is useful in giving the general idea of how composition works, let’s do a full example that you can compile yourself. Many games and simulations have creatures or objects that move around a board, map, or screen. The one thing that all of these creatures/objects have in common is that they all have-a location. In this example, we are going to create a creature class that uses a point class to hold the creature’s location.

First, let’s design the point class. Our creature is going to live in a 2d world, so our point class will have 2 dimensions, X and Y. We will assume the world is made up of discrete squares, so these dimensions will always be integers.


Note that because we’ve implemented all of our functions in the header file (for the sake of keeping the example concise), there is no Point2D.cpp.

Now let’s design our Creature. Our Creature is going to have a few properties. It’s going to have a name, which will be a string, and a location, which will be our Point2D class.


And finally, Main.cpp:

Here’s a transcript of this code being run:

Enter a name for your creature: Marvin
Marvin is at (4, 7)
Enter new X location for creature (-1 to quit): 6
Enter new Y location for creature (-1 to quit): 12
Marvin is at (6, 12)
Enter new X location for creature (-1 to quit): 3
Enter new Y location for creature (-1 to quit): 2
Marvin is at (3, 2)
Enter new X location for creature (-1 to quit): -1

Why use composition?

Instead of using the Point2D class to implement the Creature’s location, we could have instead just added 2 integers to the Creature class and written code in the Creature class to handle the positioning. However, using composition provides a number of useful benefits:

  1. Each individual class can be kept relatively simple and straightforward, focused on performing one task. This makes those classes easier to write and much easier to understand. For example, Point2D only worries about point-related stuff, which helps keep it simple.
  2. Each subobject can be self-contained, which makes them reusable. For example, we could reuse our Point2D class in a completely different application. Or if our creature ever needed another point (for example, a destination it was trying to get to), we can simply add another Point2D member variable.
  3. The complex class can have the simple subclasses do most of the hard work, and instead focus on coordinating the data flow between the subclasses. This helps lower the overall complexity of the complex object, because it can delegate tasks to the sub-objects, who already know how to do them. For example, when we move our Creature, it delegates that task to the Point class, which already understands how to set a point. Thus, the Creature class does not have to worry about how such things would be implemented.

One question that new programmers often ask is “When should I use composition instead of direct implementation of a feature?”. There’s no 100% answer to that question. However, a good rule of thumb is that each class should be built to accomplish a single task. That task should either be the storage and manipulation of some kind of data (eg. Point2D), OR the coordination of subclasses (eg. Creature). Not both.

In this case of our example, it makes sense that Creature shouldn’t have to worry about how Points are implemented, or how the name is being stored. Creature’s job isn’t to know those intimate details. Creature’s job is to worry about how to coordinate the data flow and ensure that each of the subclasses knows what it is supposed to do. It’s up to the individual subclasses to worry about how they will do it.

10.3 -- Aggregation
10.1 -- Constructor initialization lists

52 comments to 10.2 — Composition

  • jo

    Creature(std::string strName, const Point2D &cLocation)
    : m_strName(strName), m_cLocation(cLocation)

    m_cLocation(cLocation) calls copy constructor or assignment operator?
    m_cLocation and cLocation are already instantiated. thats why i asked so.

    Also when i add a copy constructor it says…………….
    class ‘Point2D’ : no copy constructor available………

  • jobin

    when i add a copy constructor it says…
    class ‘Point2D’ : no copy constructor available

  • Kinten

    When you create the Overloaded operator, it calls GetX() and GetY(), but these aren’t defined yet so it could’t use them, I am right?

    • You should actually be okay here since this will all be declared in a class declaration. Unlike normal code files, the order that you include functions in class declarations doesn’t matter.

  • thank you very mutch

    thise toturile is very usfule

  • J.D.

    Thank you for the tutorial. It helped a lot because my book didn’t go into very much detail about composition.

  • Insomniac

    Hi Alex, thanks for the great tutorial!
    Just a small remark:
    In the code above for main.cpp, line 9

    the “std::” part is obsolete (because of line 7)… just in case someone wonders.

  • include# “Cpu.h”
    include# “Motherboard.h”
    include# “Ram.h”

    class personal computer
    Cpu m_cCpu;
    Motherboard m_cMotherboard;
    Ram m_cRam;

    Personal Computer::Personal Computer (n_cCPUspeed, *str_cMOTHERBOARDModel, n_cRAMsize)
    :n_cCPU(cpuspeed), *str_motherboard(MOTHERBOARDMODEL), nRAM(Rramsize)

  • duetosideeffects

    first of all, love the tutorials: so amazing, informative, and best of all, it doesn’t baby us like some textbooks do.

    - Question: My question is why are Container classes declared the way they are, and why their default parameters are the same way.

    The real question is that I fail to see the logic behind why declaring a class within a class declaration is done with the class name and parentheses for the parameters only.
    -->(Position(1,3,4), Orientation(10, 90), “Fred”)
    -->(EnemyDrone(const Position &cPos = Position(0,0,0), const Orientation &cOrient = Orientation(0,0), …)

    (Sorry about the length, but I thought it would be better to have more info then needed than less -- I also feel like I’m slowly answering my own question asking)

  • Martin

    I wonder why you created default constructor of Creature class and set it private. When you declare (and you declared) constructor with extra parameters ( Creature(std::string strName, const Point2D &cLocation) ) default constructor should not be available. Or it is ? Because when i create some constructor with parameters in my VS 2010 default one is not implicitli created by C++ and calling it causes compile error…


  • Dr. Jekyll

    To Alex,

    I thought that you would like to know that on this page the top left hyperlink and lower right bottom of page links that usually takes you back a page instead is a link to A.5 Debugging your program (watching variables and the call stack).

    From Dr.Jekyll

    P.s Have you thought about adding a preview comment function into the leave a reply box. This could seriously reduce the amount of people forgeting to use the appropriate tags. The one in the forum is great.

  • prady

    then what is Association ? if this chapter has details for association like composition and aggregation it will be much help full for all. :)

  • jaykay

    Line 26 of Creature.h :

    out << cCreature.m_strName.c_str() << " is at " << cCreature.m_cLocation;

    Can someone explain why the c_str() function is used?


  • Patra

    Thanks for the tutorial, really informative.

    When I run this program, Point2D object is created only once, but Point2D destructor is called 2 times. Can you please help in understanding this?

    Since the constructor is called once but how can the destructed called twice?


  • Alex Bieniek

    In this lesson, you make your object classes entirely using header files. I don’t get it, I thought you couldn’t do much else in header files, outside of prototyping functions. If you can actually initialize your variables, implement functions, etc. what’s the purpose of even having a .cpp file that goes along with your .h file when you’re making objects?

    • C++ Newbie

      He did it to be concise in the example.  In reality, every function and constructor would just have a semicolon at the end of it, and the .cpp file would define everything

  • Neha Nigam

    // We don’t want people to create Creatures with no name or location
        // so our default constructor is private
        Creature() { }

    do we really need this, as when we define parameterized constructor , compiler will not provide default one

  • ranjeet

    Hi Alex,

    In below sentence i think should use named "object of class" instead of "class", and s"ub-object of class" instead of subclass, this creates a confusion in reading, class can not be created nor destroyed , this is object.  
    "When the complex class is created, the subclasses are created. When the complex class is destroyed, the subclasses are similarly destroyed."


  • Pofke1

    I was trying to create something like you, before i finished writing it, i encountered a problem (explained in code).
    Also when i execute “nname()” without “if” it works as expected.

    heres my creature.h:

    press 1 to enter a new name
    press 2 to enter new cords
    press 3 to view info
    enter a name for your creature:
    your creature name is:
    Press any key to continue . . .

    • Monil Vikam


      Try adding

      before getline, this will solve your problem
      This will clean your input basically "\n" which is residue after you enter "1\r\n"
      Currently getline is catching "\n" character from istream.

  • Pofke1

    ok thanks Monil Vikam

  • Hello Alex, a few questions:

    1. In the Creature.h example:

    Removing c_str() doesn’t affect the class and whole program compiles fine. Well, that is not the problem. The program compiles and runs with this (c_str()), is actually a problem to me. After doing a few search I came to know that we use c_str() when we pass an std::string argument and called function expects a const char* (null-terminated C-Style constant string). But I am still unable to see any importance of this here. It is everywhere std::string. Can you tell why you have used c_str().

    2. Putting the input statements for nX and nY inside a do while at least won’t result in an infinite loop if I enter ‘p’. Why you kept everything in a while? Is there a reason?

    • Alex

      1) The c_str() isn’t needed. I updated the example to remove it.

      2) Ideally, we’d want to add error handling for bad input -- it’s omitted from these examples because it’s not relevant to what I’m trying to teach. You can use a do-while or even a for loop if you want.

  • Help me Alex. I first tried to get answer from overflow, but I think question is very stupid (downvotes :-( ):

    My question could be better understood by an example. Suppose, I have to write an application that is designed (only) to take data from user (e.g. name, address etc.) and print them back to the console after submission. My complex class is "User" and I would like to use composition here. Address and Qualification details are candidates for designing sub-classes for the complex (User) class, so the tree would look like;

    User variables…

    User(complex) => User_Address(subclass 1)

    User(complex) => User_Qualification(subclass 2)

    User variables…

    There are two functions in each sub-classe and both are given public access. For sub-class User_Address, functions would be set_address() and print_address(), same with qualification sub-class (member variables like user_pin, user_contact, user_highschool etc. are private). The complex class has some private member variables like user_name, user_age etc. The complex class too has two functions set_user() to take input, and print_user() to output user data. Complex class calls its sub-classes User_Address and User_Qualification for inputting and outputting user’s address and qualification details respectively. Now, my question is, is that good coding style. I have to give public access to my sub-class functions because "User" needs to call them (or otherwise make the User class a friend of its sub-classes). Giving public-access to functions means any function/class can call it and may inadvertently change the inner parts, that was not desired. So, is there a better way to do what I am trying here.

    • Alex

      It’s fine to make public access functions for both your User class and your Address and Qualification subclasses.

      Don’t worry to so much about who has access to your accessor functions -- worry more about making sure things are properly encapsulated, so that if you ever change the internal implementation of a class, you don’t have to change every program in existence that uses it.

  • Glenn Ulysse

    Hey Alex, great tuts man, thanks a lot.

    I think I found a typo on this page :
    //original code
    PersonalComputer::PersonalComputer(int nCPUSpeed, char *strMotherboardModel, int nRAMSize)
        : m_cCPU(nCPUSpeed), m_cMotherboard(strMotherboardModel), m_cRAM(nRAMSize)
    I am pretty sure the parameters should not be int but rather respectively CPU &m_cCpu, RAM &m_cRam etc… right ? anyway as it is it won’t compile (even though i defined class for ram cpu etc)

    • Alex

      This lesson needs a bit of a rewrite. :)

      The line is correct as written.

      m_cCPU will call the CPU constructor that takes an integer to initialize m_cCPU.
      m_cMotherboard will call the Motherboard constructor that takes a C-style string to initialize Motherboard.
      m_cRAM will call the RAM constructor that takes an integer to initialize m_cRAM.

      I just didn’t include the code for those.

      This snippet is just meant to show the basics of composition -- not to be compiled itself. Check out the example below, as it’s much more comprehensive.

  • Quang

    I have a few questions needed to be cleared:
    - In previous lessons, you said that if we dont know what exactly the user gonna type so we use dynamic memory allocation. So why didnt you use it in the example ?
    - Is it better to use getline() instead of cin cuz they might include spacebar?
    - How can you do this: while (1) {//code}
    - Assume the Creature() in Creature.h is put in public, can you give me an example how’s that gonna affect our code
    - What if I want to creat a game of chess where there are pawns, knight, rocks, bishop, ….and so is the location and their movement. Will i need to build enum classes 1st??
    Thank you for your time Alex!!

    • Alex

      > In previous lessons, you said that if we dont know what exactly the user gonna type so we use dynamic memory allocation. So why didnt you use it in the example ?

      I’m not sure where I would have used it. We only need to use dynamic memory allocation if there is a need to allocate a certain amount of memory at runtime. I don’t see any cases in this example that require that.

      > Is it better to use getline() instead of cin cuz they might include spacebar?

      It’s better to use whichever fits the needs of your program. If you want the user to be able to enter spaces, then getline() is probably the better choice.

      > How can you do this: while (1) {//code}

      while(1) always evaluates to true, so this is an infinite loop (we use break statements to escape from it).

      > Assume the Creature() in Creature.h is put in public, can you give me an example how’s that gonna affect our code

      You could do something like this:

      By making the default constructor private, you’re forcing people to provide a name and location for the Creature.

      > What if I want to creat a game of chess where there are pawns, knight, rocks, bishop, ….and so is the location and their movement. Will i need to build enum classes 1st??

      That’s probably a good way to go. I’d probably define an enum for the chess piece types (pawn, knight, rook). Because the movement types are highly correlated with the piece types, I’d probably use the piece enum to drive the movement logic as well.

      • Quang

        >I’m not sure where I would have used it. We only need to use dynamic memory allocation if there is a need to allocate a certain amount of memory at runtime. I don’t see any cases in this example that require that.
        It was in 6.9 — Dynamic memory allocation with new and delete, you said: "For example, we may want to use a string to hold someone’s name, but we do not know how long their name is until they enter it" and thats the reason to use dynamic memory allocation. Is it correct?

        • Devashish

          by saying “we may want to use a string to hold someone’s name, but we do not know how long their name is until they enter it”, Alex doesn’t mean that if we don’t know what exactly the user gonna type so we use dynamic memory allocation. Suppose your program has to be designed to take user’s name as input, perform some kind of operation on it and return something based on the calculation. Here you may need some dynamic memory to be allocated, because you don’t know the exact number of characters user’s name can have. There are some other reasons why you may want to do dynamic memory allocation in this case.

          As for the example above, there is no need to dynamically allocate memory. I guess you are thinking that why Alex doesn’t use any dynamic memory to store the value of std::string cName. As far as I know, the C style string, where we define a string as an array of characters and need to dynamically allocate the array if we don’t know what would be the exact size, is an alternative to std::string. It has been previously mentioned that if there is no special reason, we should use std::string instead of C-style string because std::string is safer to use, is flexible and also an easier way to handle strings. Second, Alex said that working with dynamic memory adds up extra overhead and increases the complexity of the program. It’s also dangerous if you don’t handle dynamic memory allocation and deallocation in a sensible way. That’s why we should save ourselves from using dynamically allocated memories if there is a better option available.

  • Quang

    Thank you guys so much! But what will happen if I want to use char instead of string, will I have to use dynamic allocation?

    • Devashish

      If you wish, you can use dynamic allocation but that’s not strictly necessary. If you are sure that creature names won’t cross a certain number of characters, you can use a fixed char array of that size. But if you use dynamic allocation, make sure you deallocate the dynamically allocated memory otherwise it’ll cause a memory leak.

  • Jason

    Hi Alex,

    Just wanted to point out, as Martin did above, that it’s unnecessary to make a private default constructor because making a non-default constructor causes the compiler not to automatically create a default constructor.

    Also, in your Creature.h file you have declared the friend operator<< method and also defined its implementation. Wouldn't there be no need for the modifier "friend" if its body is inside the class?

    • Alex

      You’re right, explicitly declaring a private default constructor is extraneous if you have a non-default constructor available.

      There are three ways to implement binary operators such as operator<<: 1) As a friend member function, as we’ve shown above. 2) As a non-friend member function, where the left-hand operand is the class object. In this case, the left-hand-operand is of type ostream&, and you can’t add an overloaded operator<< to ostream, so this won’t work. 3) As a non-friend non-member function. This will work. So yes, you can make this function a non-friend as long as you move it out of the class.

  • Rahul

    In Main.cpp

    Here Point2D(4,7) constructor is called right. How memory is allocated here without ‘new’ keyword, where it is allocated, what is it scope, when it is destroyed.

    Please help me know the source to fill the knowledge gap.

  • Mr D

    Hi Alex,

    Could you explain why you’re making the overloaded output operator a friend? I thought this was only necessary if the actual function (implementation) was outside of the class body, which here is not the case.

    In lesson 9.3 you did the same thing, but then you had the implementation of the overloaded output operator outside of the class definition, hence the need to make it a friend of the class.

    • Alex

      Yes. Because the left-hand parameter is an ostream, if the overloaded operator<< weren't a friend, it would have to be implemented inside the ostream class. But we don't have access to edit ostream. Making it a friend allows us to keep the left hand operand as an ostream object while defining the function outside of the ostream class.

  • Alex Silva

    Hi Alex,

    Your answer for Mr D’s question is not clear to me. According to lesson 8.13, the friend keyword should be used to access private members outside the class. Could you explicit this? What are the private members? Who access them?

    • Alex

      The private members of the class are any member variables (or functions) declared underneath a private (or protected) access specifier. The friend function can access them. If you re-review lesson 8.13, the Humidity and Temperature examples are instructive here, as the PrintWeather() function is able to directly access the private temp and humidity variables of the classes.

      With overloaded operators, the operator being overloaded normally must belong to the class of the left operand. However, if the left-operand is a class we don’t have access to modify (e.g. ostream) or isn’t a class at all (e.g. int), then we can make the overloaded operator a friend. Overloaded operators that are friends don’t need to be defined inside the class of the left operand.

      So, in this sense, the friend keyword serves two different but useful purposes.

  • Jess

    Hi, Alex! I love your tutorials - they are really detailed and informative. I have a question regarding some of the code in Creature.h (Lines 19-22):

    Why must Point2D &cLocation be passed in as a const? When I remove the const the code doesn’t compile.

    Thank you! (And apologies in advance if this is a silly question.)

    • Alex

      I think the problem here may be related to how we’re constructing our Creature:

      Note that Point2D(4, 7) is an anonymous variable that exists just within the expression. Anonymous objects can only be passed by value or const reference.

  • tata

    Hi, could someone confirm the following:

    1) m_cLocation(cLocation) is calling the (default) copy constructor of Point2D; this is so because Const or not, m_cLocation is being created at the time of the initialization

    2) the above would require a user-defined copy constructor for Point2D if Point2D contains dynamically allocated members

    3) the following is valid:
    Cents cMark(5); // would call Cents constructor
    Cents cNancy(cMark); // would call Cents copy constructor

    4) Is the following valid:
    Cents cMark(5); // would call Cents constructor
    Cents cNancy;
    cNancy(cMark); // would this call Cents assignment constructor instead?

    (Below is a related question relating to the timing of member creation, please disregard if it’s inappropriate for this section)

    5) Is the following correct:

    if a class has a static member such as - static int nValue;

    nValue would not be created until a line (after and outside the class definition) such as - int className::nValue = 3;?

Leave a Comment




20 − 10 =

Put C++ code inside [code][/code] tags to use the syntax highlighter