7.11 — Introduction to class types

Back in lesson 1.3 -- Introduction to variables, we defined an object in C++ as, “a piece of memory that can be used to store values”. An object with a name is called a variable.

In “traditional programming” (what we’ve been doing up to this point), programs are basically lists of instructions to the computer that define objects and then manipulate those objects (typically via functions). The objects and the functions that work on those objects are separate entities that are then combined together to produce the desired result.

Consider the following program:

In the above program, the function that prints a Fraction is separate from the Fraction itself, connected only via the Fraction input parameter.

Objects in real life

Take a look around you -- everywhere you look are objects: books and buildings and food and even you. Objects have two major components to them: 1) A list of relevant properties (e.g. weight, color, size, solidity, shape, etc…), and 2) Some number of behaviors that they can exhibit (e.g. making a noise, moving to a new location, etc…). These properties and behaviors are inseparable. A person has a weight and a size, a cat meows, etc…

The struct objects we’ve been defining in our programs already have properties. Consider the Fraction struct above, it defines some properties (the members id, age, and wage), which we can access through the member selection operator (operator .). However, these objects are deficient in that they don’t have any associated behaviors.

Intro to class type objects and member functions

C++ provides us with the ability to create objects that tie together both properties and behaviors into a self-contained, reusable package. These objects that contain both properties and behaviors are called class type objects, or often just classes. Classes form the cornerstone of object-oriented programming, which you’ve probably heard of (but if not, that’s okay too).

As an aside...

The word object is often used ambiguously in C++. In traditional programming, an object is a piece of memory that can be used to store values. In object-oriented programming, an object is a class type object that contains both properties and behaviors.

Most of the time, in C++, when you hear the word “object”, it actually means a class type object, not a traditional programming object.

Wheres properties are implemented as “data members”, behaviors are implemented as “function members” (more often called “member functions”). A member function of a class is a function that is defined as part of the class itself.

As an aside...

If you want a full program that compiles, you can use this one:

The interesting thing to note here is the printFraction function. Much like numerator and denominator are data members of the Fraction struct, the printFraction function is a member function[def] of our FractionClass. Member functions are essentially just normal functions that are associated with a specific type.

Whereas printFraction() took a Fraction as a parameter (printFraction(f)), normal member function are invoked via a slightly different syntax (f.printFraction()).

member functions are invoked on an object, which becomes the implicit subject of that function. Thus, when we say f.print(), we're saying "call member function print() on object f". It's effectively a different syntax for a similar thing, but it helps make it clear that print() is a member function of whatever type f is.

Whiel add
While this doesn't seem like a big change, it is, when coupled with a few

Rather than being focused on writing functions, we're focused on defining objects that have a well-defined set of behaviors. This is why the paradigm is called "object-oriented".

This allows programs to be written in a more modular fashion, which makes them easier to write and understand, and also provides a higher degree of code-reusability. These objects also provide a more intuitive way to work with our data by allowing us to define how we interact with the objects, and how they interact with other objects. OOP doesn't replace traditional programming methods. Rather, it gives you additional tools in your programming tool belt to manage complexity when needed.

Note that the term "object" is overloaded a bit, and this causes some amount of confusion. In traditional programming, an object is a piece of memory to store values. And that's it. In object-oriented programming, an "object" implies that it is both an object in the traditional programming sense, and that it combines both properties and behaviors.

[section]Data-only structs are like objects with no behaviors[/section]

In the prior lesson, we defined some data-only structs:

Note that object you is an object that has properties (the members id, age, and wage). We use the member selection operator (operator .) to select a specific member.

All that's missing are the behaviors.

[section]Classes are data-only structs with behaviors[/section]

In C++, we typically call objects with behaviors as [def]classes, or class types. Classes have a few notable properties:
1) They can self-initialize to a non-zero value
2) Properties typically aren't accessible directly
3) They have functions (behaviors) that can also be accessed via the member selection operator.

We'll introduce our first class, std::string, in the next tutorial, but just as an example:

The above prints:

Hello, world! 13

Object-oriented objects in C++ are class types (and thus should generally be passed via reference).

Defining your own objects

Just as you can define your own data-only structs, you can define your own classes. We have many chapters devoted to this topic later in the tutorial series!

For the time being, we'll focus more on using classes.

Using objects

At the beginning of this chapter, we noted that most of the types in the standard library are class types.

5.9 -- Random number generation
8.14 -- Struct passing and miscellany

8 comments to 7.11 — Introduction to class types

  • beginnercpp

    Dear all friends,
    I am a beginner with C++. Actually it's very difficult for me to complete exercises OPP at the begining. My teacher gave us some exercises. I have tried but not success. So, please help me on these exercises.

    Exercise 1:(3Points)
    The 10 digit International Standard Book Number(ISBN)is a unique numeric commercial book
    identifier developed by the International Organization for Standardization(ISO).It was used until
    2007,after which a 13 digit ISBN number was defined.
    The 10 digit ISBN consists of 9 identifier digits and one check digit at the end.It is usually written
    in the following form


    where C denotes the check digit. The identifier digits are in the range 0-9,the check digit can be
    either in the range 0-9 or be the letter ‚X’.

    You should model an ISBN number as a C++ class, therefore:
    • Draw a UML class diagram of the ISBN class(model the 9 identifier digits as one single
    integer value with nine digits (e.g.0-233-45678 is modeled as the integer 23345678) ,the
    check digit as a single character value)
    • Declare your modeled ISBN class in C++, including a constructor that takes an integer and a
    Character to initialize the corresponding member values, in a file named„ isbn.h“
    • Implement the constructor of the class in a file named „isbn.cpp“. The constructor should
    Initialize the member values of the object using the given parameter values.


    Exercise 2:(2Points)
    Add a member function

    void show () const;

    to the ISBN class which prints the whole ISBN number (including check digit) on the screen in the following format:


    If the number is shorter than 9 digits, fill it up with 0s to the left.
    Explain in comments what the keyword„ const“ means in this case (void show () const)and why it is good (or not good) to be used for this function.

    Exercise 3:(1Point)
    Write a main function in a file called„sheet1.cpp“ which creates three ISBN objects (enter their
    ISBN number as integer and check character directly into the C++source, you do not need to read
    Them from std::cin) and prints out their numbers in the format shown in exercise 2.
    Create a simple Make file and compile the program (consisting of the two.cpp implementation files
    As well as the .h header file).Execute your program.

    Thank you very much for your help.

  • subramanyam

    Its very nice material..

  • Bruce

    I have been rather confused by some of the terminology of OOP, such as 'class', and 'wrapper', etc.; however, it appears as though these things are simply evolutions of the old 'subroutine' construct. Using a subroutine is now handled by the language which acts as a 'traffic controller' making it unnecessary for the programmer to keep up with 'returns' and allowing program flow to continue in any direction. If this is the case then it is not so hard to understand.

  • Krishna
    Hi Alex,
    I am looking at resources/web pages which can provide exhaustive details of Object Layout in Memory Basically I am looking at concepts like 
    1. Memory layout of an object of a base class with/without member data and with/without member functions.
    2. Memory layout of an object of a base class with/without virtual member functions.
    3. Memory layout of a object of a derived class
    4. vtable concepts
    5. vtable layout in memory
    It would be great if you could add these details in your tutorial which looks very informative and exhaustive in certain areas.  
  • Pathik

    Does the date at the top of the page tell when you wrote the page and published it?

    [ Yes, that is correct. -Alex ]

  • Pathik

    So object oriented programming can only be done with C++...not java or anything other?

  • Hiu

    I'm thrilled after I read this article!! At this moment I'm taking intermediate C++ programming, and soon our teacher will teach us object-oriented programming (hope I'm right). And again, thank you for creating such a great C++ resource for programmers

Leave a Reply

You can use these HTML tags

<a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code class="" title="" data-url=""> <del datetime=""> <em> <i> <q cite=""> <s> <strike> <strong> <pre class="" title="" data-url=""> <span class="" title="" data-url="">