A compiler, like GCC, to translate the C++ code into a language that
the computer will understand
There are many text editors and compilers to choose from. In this tutorial, we
will use an IDE (see below).
C++ Install IDE
An IDE (Integrated Development Environment) is used to edit AND compile the code.
Popular IDE's include Code::Blocks, Eclipse, and Visual Studio. These are all
free, and they can be used to both edit and debug C++ code.
Note: Web-based IDE's can work as well, but functionality is limited.
We will use Code::Blocks in our tutorial, which we believe is a good place to start.
You can find the latest version of Codeblocks at http://www.codeblocks.org/downloads/26.
Download the mingw-setup.exe file, which will install the text editor with
a compiler.
C++ Quickstart
Let's create our first C++ file.
Open Codeblocks and go to File > New > Empty File.
Write the following C++ code and save the file as myfirstprogram.cpp (File > Save File as):
myfirstprogram.cpp
#include <iostream> using namespace std;
int main() {
cout << "Hello World!"; return 0; }
Don't worry if you don't understand the code above - we will discuss it in detail in later chapters. For now, focus on how to run the code.
In Codeblocks, it should look like this:
Then, go to Build > Build and Run to run (execute) the program. The result will look something to this:
Hello World! Process returned 0 (0x0) execution time : 0.011 s Press any
key to continue.
Congratulations! You have now written and executed your first C++ program.
Learning C++ At W3Schools
When learning C++ at W3Schools.com, you can use our "Run Example" tool, which shows both the code and the result. This will make it easier for
you to understand every part as we move forward:
Line 1:#include <iostream> is a
header file library that lets us work with input and output objects, such as
cout (used in line 5). Header files add functionality to C++ programs.
Line 2:using namespace std
means that we can use names for objects and variables from the
standard library.
Don't worry if you don't understand how #include <iostream> and using namespace std works. Just think of it as something that (almost) always appears in your program.
Line 3: A blank line. C++ ignores white space.
Line 4: Another thing that always appear in a C++ program, is int main(). This is called a
function. Any code inside its curly brackets {} will be executed.
Line 5:cout (pronounced "see-out") is an
object used to output/print text. In our example it will output "Hello World".
Note: Every C++ statement ends with a semicolon ;.
Note: The body of int main() could also been written as: int main () { cout << "Hello World! "; return 0;
}
Remember: The compiler ignores white spaces. However, multiple lines makes the code more readable.
Line 6:return 0 ends the main function.
Omitting Namespace
You might see some C++ programs that runs without the standard namespace library. The using namespace std line can be omitted and replaced with the std keyword,
followed by the :: operator
for some objects:
Example
#include <iostream>
int main() { std::cout << "Hello World!"; return 0; }
Both \n and endl
are used to break lines.
However, \n is used more often and is the preferred way.
C++ Comments
C++ Comments
Comments can be used to explain C++ code, and to make it more readable. It can also be used to
prevent execution when testing alternative code. Comments can be singled-lined or multi-lined.
Single-line comments start with two forward slashes (//).
Any text between // and the end of the line
is ignored by the compiler (will not be executed).
This example uses a single-line comment before a line of code:
In C++, there are different types of variables (defined with different keywords), for example:
int - stores integers (whole numbers), without decimals, such as 123 or -123
double - stores floating point numbers, with decimals, such as 19.99 or -19.99
char - stores single characters, such as 'a' or 'B'.
Char values are surrounded by single quotes
string - stores text, such as "Hello World".
String values are surrounded by double quotes
bool - stores values with two states:
true or false
Declaring (Creating) Variables
To create a variable, you must specify the type and assign it a value:
Syntax
typevariable = value;
Where type is one of C++ types (such as int), and
variable is the name of the variable (such as x or
myName). The equal sign is used to assign values to the variable.
To create a variable that should store a number, look at the following example:
Example
Create a variable called myNum of type int and assign it the value 15:
However, you can add the const keyword if
you don't want others (or yourself) to override existing values (this will declare the
variable as "constant", which means unchangeable and read-only):
Example
const int myNum = 15; // myNum will always be 15 myNum = 10; // error:
assignment of read-only variable 'myNum'
All C++ variables must be
identified with unique names.
These unique names are called identifiers.
Identifiers can be short names (like x and y) or more descriptive names (age, sum, totalVolume).
The general rules for constructing names for variables (unique identifiers) are:
Names can contain letters, digits and underscores
Names must begin with a letter or an underscore (_)
Names are case sensitive ("myVar" and "myvar" are different variables)
Names cannot contain whitespaces or special characters like !, #, %, etc.
Reserved words (like C++ keywords, such as int) cannot be used as names
C++ User Input
C++ User Input
You have already learned that cout is used to output (print) values. Now we will use cin to get user input.
cin is a predefined variable that reads data from the keyboard with the extraction operator (>>).
In the following example, the user can input a number, which is stored in the
variable x. Then we print the value of x:
Example
int x; cout << "Type a number: "; // Type a number and
press enter cin >> x; // Get user
input from the keyboard cout << "Your number is: " << x;
// Display the input value
The data type specifies the size and type of information the variable will store:
Data Type
Size
Description
int
4 bytes
Stores whole numbers, without decimals
float
4 bytes
Stores fractional numbers, containing one or more decimals. Sufficient for
storing 7 decimal digits
double
8 bytes
Stores fractional numbers, containing one or more decimals. Sufficient for
storing 15 decimal digits
boolean
1 byte
Stores true or false values
char
1 byte
Stores a single character/letter/number, or ASCII values
Use int when you need to store a whole number without decimals, like 35 or 1000, and float or double when you need a
floating point number (with decimals), like 9.99 or 3.14515.
The precision of a floating point value indicates how many digits the value can have
after the decimal point.
The precision of float is only six or seven
decimal digits, while double variables have a precision
of about 15 digits. Therefore it is safer to use double for most calculations.
Scientific Numbers
A floating point number can also be a scientific number with an "e" to indicate the power of 10:
The string type is used to store a sequence of characters (text).
This is not a built-in type, but it behaves like one in its most basic usage. String values must be surrounded by double quotes:
Example
string greeting = "Hello"; cout << greeting;
To use strings, you must include an additional header file in the source
code, the <string> library:
Example
// Include the string library #include <string>
// Create a string variable string greeting = "Hello";
Although the + operator is often used to add together two values, like in the example above, it can also be used to add together a variable and a value, or a variable and another variable:
Note that we added a space after firstName to create a space between John and Doe on output.
String Length
A string in C++ is actually an object, which contain functions that can perform certain operations on strings. For example, the length of a string can be found with the length()
function:
Example
string txt = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; cout << "The length of the txt
string is: " << txt.length();
It is possible to use the extraction operator >> on cin to display a string entered by a user:
Example
string firstName; cout << "Type your first name: "; cin >>
firstName;
// get user input from the keyboard cout << "Your name is: " <<
firstName;
// Type your first name: John // Your name is: John
However, cin considers a space (whitespace, tabs, etc) as a terminating
character, which means that it can only display a single word (even if you type
many words):
Example
string fullName; cout << "Type your full name: "; cin >>
fullName; cout << "Your name is: " <<
fullName;
// Type your full name: John Doe // Your name is: John
From the example above, you would expect the program to print "John Doe", but it only prints "John".
That's why, when working with strings, we often use the getline()
function to read a line of text. It takes cin as the first parameter, and the string
variable as second:
Example
string fullName; cout << "Type your full name: ";
getline (cin, fullName); cout << "Your name is: " <<
fullName;
// Type your full name: John Doe // Your name is: John Doe
If you try to add a number to a string, an error occurs:
Example
string x = "10";
int y = 20;
string z = x + y;
Omitting Namespace
You might see some C++ programs that runs without the standard namespace library. The using namespace std line can be omitted and replaced with the std keyword,
followed by the :: operator
for string (and cout) objects:
In the example above we use two variables, x and y,
to test whether x is greater than y
(using the > operator). As x is 20, and y is 18, and we know that 20 is greater than 18, we print to the screen that "x is greater than y".
The else Statement
Use the else statement to specify a block of code to be executed if the condition is false.
Syntax
if (condition) { // block of code to be executed if the
condition is true } else { // block of code to be executed
if the condition is false }
Example
int time = 20; if (time < 18) { cout << "Good
day."; } else { cout << "Good
evening."; } // Outputs "Good evening."
In the example above, time (20) is greater than 18, so the condition is false.
Because of this, we move on to the else condition and print to the screen "Good
evening". If the time was less than 18, the program would print "Good day".
The else if Statement
Use the else if statement to specify a new condition if the first condition is false.
Syntax
if (condition1) { // block of code to be executed if
condition1 is true } else if (condition2) { // block of
code to be executed if the condition1 is false and condition2 is true
} else { // block of code to be executed if the condition1 is false
and condition2 is false }
Example
int time = 22; if (time < 10) { cout << "Good
morning."; } else if (time < 20) { cout << "Good
day."; } else { cout << "Good evening."; }
// Outputs "Good evening."
In the example above, time (22) is greater than 10, so the first condition is false. The next condition, in the
else if statement, is also false, so we move on to the else
condition since condition1 and condition2 is both false - and print to the screen "Good
evening".
However, if the time was 14, our program would print "Good day."
Short Hand If...Else (Ternary Operator)
If you have only one statement to execute, one for if, and one for else, you can put it all on the same line:
When C++ reaches a break
keyword, it breaks out of the switch block.
This will stop the execution of more code and case testing inside
the block.
When a match is found, and the job is done, it's time for a break. There is no need for more testing.
A break can save a lot of execution time because it "ignores" the execution
of all the rest of the code in the switch block.
The default Keyword
The default keyword specifies some code to run if there is no
case match:
Example
int day = 4; switch (day) { case 6: cout << "Today
is Saturday";
break; case 7: cout << "Today
is Sunday";
break; default: cout << "Looking
forward to the Weekend";
} // Outputs "Looking forward to the Weekend"
Note: Do not forget to increase the variable used in the condition, otherwise
the loop will never end!
The Do/While Loop
The do/while loop is a variant of the while loop. This loop will
execute the code block once, before checking if the condition is true, then it will
repeat the loop as long as the condition is true.
Syntax
do { // code block to be executed }
while (condition);
The example below uses a do/while loop. The loop will always be
executed at least once, even if the condition is false, because the code block
is executed before the condition is tested:
Example
int i = 0; do {
cout << i << "\n";
i++; } while (i < 5);
Statement 1 sets a variable before the loop starts (int i = 0).
Statement 2 defines the condition for the loop to run (i must be less than
5). If the condition is true, the loop will start over again, if it is false,
the loop will end.
Statement 3 increases a value (i++) each time the code block in the loop has
been executed.
Another Example
This example will only print even values between 0 and 10:
Example
for (int i = 0; i <= 10; i = i + 2) {
cout << i << "\n";
}
Arrays are used to store multiple values in a single variable, instead of declaring separate variables for each
value.
To declare an array, define the variable type, specify the name
of the array followed by square brackets
and specify the number of elements it should store:
string cars[4];
We have now declared a variable that holds an array of four strings. To insert
values to it, we can use an array literal - place the values in a
comma-separated list, inside curly braces:
In the example above, the & operator was used to create a reference variable.
But it can also be used to get the memory address of a variable, which is the
location of where the variable is stored on the computer.
When a variable is created in C++, a memory address is assigned to the variable.
And when we assign a value to the variable, it is stored in this memory
address.
To access it, use the &
operator, and the result will represent where the variable is stored:
Note: The memory address is in hexidecimal form (0x..). Note
that
you may not get the same result in your program.
And why is it useful to know the memory address?
References and Pointers (which you will learn about in the next chapter)
are important in C++, because they give you the
ability to manipulate the data in the computer's memory - which can reduce the code and improve the perfomance.
These two features are one of the things that make C++ stand out from other
programming langues, like Python and Java.
C++ Pointers
Creating Pointers
You learned from the previous chapter, that we can get the memory
address of a variable by using the &
operator:
Example
string food = "Pizza";
// A food variable of type string
cout <<
food; // Outputs the value of food (Pizza)
cout << &food; // Outputs the memory address of food (0x6dfed4)
A pointer however, is a variable that stores the memory address as its value.
A pointer variable points to a data type (like int or string) of the same
type, and is created with the * operator. The address of the variable you're working with is assigned to the pointer:
Example
string food = "Pizza"; // A food variable
of type string string* ptr =
&food; // A pointer variable, with the name
ptr, that stores the
address of food
// Output the value of food (Pizza) cout << food << "\n";
// Output
the memory address of food (0x6dfed4) cout << &food << "\n";
//
Output the memory address of food with the pointer (0x6dfed4) cout <<
ptr << "\n";
Create a pointer variable with the name ptr, that points to a string variable, by using the
asterisk sign
* (string* ptr).
Note that the type of the pointer has to match the type of the variable you're
working with.
Use the & operator to store the memory address of the
variable called food, and assign it to the pointer.
Now, ptr holds the value of food's memory address.
Tip: There are three ways to declare pointer variables, but the first way is preferred:
In the example above, we used the pointer variable to get the memory address of a variable
(used together with the &reference operator). However, you can also
use the pointer to get the value of the variable, by using the * operator
(the dereference operator):
A function is a block of code which only runs when it is called.
You can pass data, known as parameters, into a function.
Functions are used to perform certain actions, and they are
important for reusing code: Define the code once, and use it many times.
Create a Function
C++ provides some pre-defined
functions, such as main(), which is used to
execute code. But you can also
create your own functions to perform certain actions.
To create (often referred to as declare) a function, specify the name of the function, followed by parentheses ():
Syntax
void myFunction() {
// code to be executed }
Example Explained
myFunction() is the name of the function
void means that the function does not have a
return value. You will learn more about return values later in the next chapter
inside the function (the body), add code that defines what the function should do
Call a Function
Declared functions are not executed immediately. They are "saved for later
use", and will be executed later, when they are called.
To call a function, write the function's name followed by two parentheses ()
and a semicolon ;
In the following example, myFunction() is used to print a text (the action), when it is called:
Example
Inside main,
call
myFunction():
// Create a function void myFunction() {
cout << "I just got executed!"; }
int main() { myFunction(); // call the function return 0; }
Declaration: the function's name, return type, and parameters (if any)
Definition: the body of the function (code to be executed)
void myFunction() { // declaration //
the body of the function (definition) }
Note: If a user-defined function, such as myFunction() is declared after the main() function,
an error will occur. It is because C++ works from top to bottom; which means that if the function is not declared above
main(), the program is unaware of it:
Example
int main() {
myFunction(); return 0; }
void myFunction() {
cout << "I just got executed!"; }
However, it is possible to separate the declaration and the definition of the function - for code optimization.
You will often see C++ programs that have function declaration above main(),
and function definition below main(). This will make the code
better organized and easier to read:
Example
// Function declaration void myFunction();
// The main method int main() {
myFunction(); // call the function return 0; }
// Function definition void myFunction() {
cout << "I just got executed!"; }
Information can be passed to functions as a parameter. Parameters act as
variables inside the function.
Parameters are specified after the function name, inside the parentheses.
You can add as many parameters as you want, just separate them with a comma:
Syntax
void functionName(parameter1, parameter2, parameter3) {
// code to be executed }
The following example has a
function that takes a string called fname as parameter.
When the function is called, we pass along a first name,
which is used inside the function to print the full name:
When a parameter is passed to the function, it is called an argument. So, from the example above: string fname is a parameter, while Liam, Jenny and Anja are arguments.
Multiple Parameters
You can add as many parameters as you want:
Example
void myFunction(string fname, int age) { cout << fname << " Refsnes.
" << age << " years old. \n"; }
Note that when you are working with multiple parameters, the function call must
have the same number of arguments as there are parameters, and the arguments must be passed in the same order.
Return Values
The void keyword, used in the examples above, indicates that the
function should not return a value. If you
want the function to return a value, you can use a data type (such as int,
string, etc.) instead of void, and use the return
keyword inside the function:
Note: Multiple functions can have the same name
as long as the number and/or type of parameters are different.
C++ Classes and Objects
C++ Classes/Objects
C++ is an object-oriented programming language.
Everything in C++ is associated with classes and objects, along with its attributes and
methods. For example: in real life, a car is an object. The car has attributes, such as weight and color, and
methods, such as drive and brake.
Attributes and methods are basically variables and
functions that belongs to the class. These are often referred to as
"class members".
A class is a user-defined data type that we can use in our program, and it
works as an object constructor, or a "blueprint" for creating objects.
Create a Class
To create a class, use the class keyword:
Example
Create a class called "MyClass":
class MyClass {
// The class public:
// Access specifier int myNum; //
Attribute (int variable) string myString; //
Attribute (string variable) };
Example explained
The class keyword is used to create a class called MyClass.
The public keyword is an access specifier, which specifies that members (attributes and methods) of the class are accessible from outside the class. You will learn more about access specifiers later.
Inside the class, there is an integer variable
myNum and a string variable myString. When variables are declared
within a class, they are called attributes.
At last, end the class definition with a semicolon ;.
Create an Object
In C++, an object is created from a class. We have already created the class named MyClass,
so now we can use this to create objects.
To create an object of MyClass, specify the
class name, followed by the object name.
To access the class attributes (myNum and myString), use the dot syntax (.)
on the object:
Example
Create an object called "myObj" and access
the attributes:
class MyClass { // The class public:
// Access specifier int myNum; //
Attribute (int variable) string myString; //
Attribute (string variable) };
int main() { MyClass myObj;
// Create an object of MyClass
// Access attributes and set values myObj.myNum
= 15;
myObj.myString = "Some text";
To define a function outside the class definition, you have to declare it
inside the class and then define it outside of the class. This is done by specifiying the
name of the class, followed the scope resolution :: operator,
followed by the name of the function:
Outside Example
class MyClass { // The class
public:
// Access specifier void myMethod(); // Method/function
declaration };
// Method/function definition outside the class void
MyClass::myMethod() { cout << "Hello World!"; }
int main() { MyClass
myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method return 0; }
Note: The constructor has the same name as the class, it is always public, and it does not have any return value.
Constructor Parameters
Constructors can also take parameters (just like regular functions), which can be
useful for setting initial values for attributes.
The following class have brand, model and year attributes, and a constructor with
different parameters. Inside the constructor we set the attributes equal to the
constructor parameters (brand=x, etc). When we call the constructor
(by creating an object of the class), we pass parameters to the constructor, which will set the value of
the corresponding attributes to the same:
Example
class Car { // The class public: // Access specifier
string brand; // Attribute string model; // Attribute
int year; // Attribute Car(string x, string y, int z)
{ // Constructor with parameters brand =
x; model = y;
year = z; } };
int main() { //
Create Car objects and call the constructor with different values
Car carObj1("BMW", "X5", 1999); Car carObj2("Ford", "Mustang",
1969);
Just like functions, constructors can also be defined outside the class.
First, declare the constructor inside the class, and then define it outside of the
class by specifying the name of the class, followed by the scope resolution ::
operator, followed by the name of the constructor (which is the same as the
class):
Example
class Car { // The class
public: // Access
specifier string brand; // Attribute
string model; // Attribute int year;
// Attribute Car(string x, string y, int z); //
Constructor declaration };
// Constructor definition outside the
class Car::Car(string x, string y, int z) { brand = x;
model = y; year = z; }
int main() { // Create
Car objects and call the constructor with different values Car
carObj1("BMW", "X5", 1999); Car carObj2("Ford", "Mustang", 1969);
The public keyword is an access specifier.
Access specifiers define how the members (attributes and methods) of a class can
be accessed. In the example above, the members are public - which means that they
can be accessed and modified from outside the code.
However, what if we want
members to be private and hidden from the outside world?
In C++, there are three access specifiers:
public - members are accessible from outside the class
private - members cannot be accessed (or
viewed) from outside the class
protected - members cannot be accessed from
outside the class, however, they can be accessed in inherited classes. You will learn more about Inheritance later.
In the following example, we demonstrate the differences between public and private members:
Example
class
MyClass { public: // Public access
specifier int x; // Public attribute private: // Private access specifier
int y; // Private attribute };
Note: It is possible to access private members of a class
using a public method inside the same class. See the next chapter (Encapsulation)
on how to do this.
Tip: It is considered good practice to declare your class attributes as private (as
often as you can). This will reduce the possibility of yourself (or others) to mess up the code. This is also the
main ingredient of the Encapsulation
concept, which you will learn more about in the next chapter.
Note: By default, all members of a class is private if you don't specify an access specifier:
Example
class
MyClass { int x; // Private attribute int y; // Private attribute };
C++ Encapsulation
Encapsulation
The meaning of Encapsulation, is to make sure that
"sensitive" data is hidden from users. To achieve this, you must declare class variables/attributes as private (cannot
be accessed from outside the class). If you want others to read or modify the
value of a private member, you can provide public getter and
setter methods.
Access Private Members
To access a private attribute, use public "getter" and "setter" methods:
Example
#include <iostream> using namespace std;
class Employee {
private: // Private attribute int salary;
The salary attribute is private,
which have restricted access.
The public setSalary() method takes a parameter (s) and assigns it to the
salary attribute (salary = s).
The public getSalary() method returns the value of
the private salary attribute.
Inside main(), we create an object of the Employee class. Now we can use the
setSalary() method to set the value of the
private attribute to 50000. Then we call the
getSalary() method on the object to return the value.
Why Encapsulation?
It is considered good practice to declare your class attributes as private (as
often as you can). Encapsulation ensures better control of your data,
because you (or others) can change one part of the code without affecting other parts
Increased security of data
C++ Inheritance
C++ Inheritance
In C++, it is possible to inherit attributes and methods from one class to another. We group the "inheritance concept" into two categories:
derived class (child) - the class that inherits from another class
base class (parent) - the class being inherited from
In the example below, the Car class
(child) inherits the attributes and methods from the Vehicle class
(parent):
Example
// Base class class Vehicle { public:
string brand = "Ford"; void honk() {
cout << "Tuut, tuut! \n" ; } };
// Derived
class class Car: public Vehicle { public:
string model = "Mustang"; };
int main() { Car myCar;
myCar.honk(); cout << myCar.brand + " " + myCar.model;
return 0; }
You learned from the Access Specifiers chapter that there are three
specifiers available in C++. Until now, we have only used public (members of a
class are accessible from outside the class) and private (members can only be
accessed within the class). The third specifier, protected, is similar to
private, but it can also be accessed in the inherited class:
Example
// Base class class
Employee { protected: // Protected access specifier
int salary; };
// Derived class class Programmer: public Employee {
public: int bonus; void
setSalary(int s) { salary = s;
} int getSalary() {
return salary; } };
