Home/Blog/Programming/Intermediate C++ tutorial: Strings, maps, memory, and more

Intermediate C++ tutorial: Strings, maps, memory, and more

15 min read

Aug 12, 2020

Become a Software Engineer in Months, Not Years

From your first line of code, to your first day on the job — Educative has you covered. Join 2M+ developers learning in-demand programming skills.

C++ is one of the oldest programming languages, created back in 1979. It has remained a crucial language for modern developers for its uses in large system performance for fields like video game development, operating systems, browsers, and both office and medical software.

It’s easy to see why developers want to learn to code in C++. If you’re already learning C++, you’ve probably noticed that it can be difficult to pick up.

Worry not!, today we’ll walk you through some intermediate C++ concepts and examples to get you one step closer to mastering this challenging but sought-after language.

Using object-oriented programming in C++#

C++ is an object-oriented language. This paradigm is one of its defining differences from C and C#. In C++ we accomplish this by using objects and classes to store and manipulate data. Through this object-oriented approach, developers can implement the strategies of inheritance, polymorphism, abstraction, and encapsulation.

For a refresher on object-oriented concepts and terms, see What is Object Oriented Programming?.

When C++, it’s important to understand how to make the most of its OOP capabilities. Below, we’ll explore some examples of each of the core OOP strategies: inheritance, polymorphism, abstraction, and encapsulation.

Using Inheritance in C++#

Setting up inheritance relationships in C++ is easy; we simply append a classes declaration with : [parent name](). This allows us to share both public variables and methods from parent class to child.

Below, you’ll see how we can use this to create the BankAccount class, pulling from the Account class.

#include <iostream>
 
class Account{
 
public:
   Account(double b): balance(b){}
 
   void deposit(double amt){
     balance += amt;
   }
 
   void withdraw(double amt){
     balance -= amt;
   }
 
   double getBalance() const {
     return balance;
   }
 
private:
   double balance;
 
};
 
class BankAccount: public Account{
 
public:
  // using Account::Account;
  BankAccount(double b): Account(b){}
 
  void addInterest(){
    deposit( getBalance()*0.05 );
  }
};
 
int main(){
 
  std::cout << std::endl;
 
  BankAccount bankAcc(100.0);
  bankAcc.deposit(50.0);
  bankAcc.deposit(25.15);
  bankAcc.withdraw(30);
  bankAcc.addInterest();
 
  std::cout << "bankAcc.getBalance(): " << bankAcc.getBalance() << std::endl;
 
  std::cout << std::endl;
 
}

Using Polymorphism in C++#

One of the most common applications of polymorphism in C++ is through function overriding. By having two functions of the same name in different classes, we can create code that completes different behavior depending on the inheritance of the selected object.

Below, we’ll see an example of how polymorphism can be used to implement a sample Draw function across different shape classes:

To focus on overridden functions, we’ve just filled each Draw with a simple unique count statement. However, this could be replaced by a drawing algorithm and behave in the same way.

#include <iostream>
class Shape {
public:
  Shape() {}
  //defining a virtual function called Draw for shape class
  virtual void Draw() { std::cout << "Drawing a Shape" << std::endl; }
};
class Rectangle : public Shape {
public:
  Rectangle() {}
  //Draw function defined for Rectangle class
  virtual void Draw() { std::cout << "Drawing a Rectangle" << std::endl; }
};
class Triangle : public Shape {
public:
  Triangle() {}
  //Draw function defined for Triangle class
  virtual void Draw() { std::cout << "Drawing a Triangle" << std::endl; }
};
class Circle : public Shape {
public:
  Circle() {}
  //Draw function defined for Circle class
  virtual void Draw() { std::cout << "Drawing a Circle" << std::endl; }
};
int main()
{
  Shape* s;
  Triangle  tri;
  Rectangle rec;
  Circle    circ;
  // store the address of Rectangle
  s = &rec;
  // call Rectangle Draw function
  s->Draw();
  // store the address of Triangle
  s = &tri;
  // call Triangle Draw function
  s->Draw();
  // store the address of Circle
  s = &circ;
  // call Circle Draw function
  s->Draw();
  return 0;
}

Above we see a parent class, shape, and three child classes Triangle, Rectangle, and Circle. The process of drawing each shape will differ depending on the shape itself. This leads us to use polymorphism to define a Draw function for each of the classes.

C++ will prioritize the local function over the parent Draw function by default. This means that we can call Draw without worrying about which shape class the object is. If it is a rectangle the output will be “Drawing a rectangle”. If it’s a triangle, it will output “Drawing a triangle”, and so on.

Here we first create an abstraction class that initializes private variables a and b. We also define two public functions, set and display. This achieves encapsulation by separating variables from the outside world, so we can only access them via public functions. Using set, we then change the values from inside main. Finally, we print the variables using display.

This ensures that users cannot directly change variables but can use them through the getter and setter functions, achieving abstraction by keeping the variables themselves secure and hidden from users.

How do Strings work in C++?#

Strings in C++ are similar to those of other languages, in that they’re a collection of ordered characters. However, in C++, there are two ways to create strings, either using C style strings or the C++ string class.

C style strings are the old-fashioned way of creating strings in C++. Rather than a standard string object, C-style strings consist of a null terminated array of characters ending with the special character \0. Due to this hidden character, C-style strings are always a length of one more character than the visible number of characters.

This size can either be unspecified to be set automatically to the required size or manually to any desired size.

char str[] = "Educative"; // automatic length set to 10 char str[10] = "Educative"; // manual set length to 10

We can also create strings in C++ using the C++ string class that is built into the standard C++ library. This is the more popular method, as all memory management, allocation, and null termination are internally handled by the class. Another advantage is that the length of the string can be changed at runtime thanks to the dynamic allocation of memory.

Overall, these changes make the string class more resistant to errors and provide many built-in functions like append(), which adds onto the end of the string and length(), which returns the number of characters in the string.

Below, we’ll learn how to use functions like these to complete common manipulations of strings.

How to calculate the length of string#

To calculate the length of a string we can use either the length() or size() functions. Each performs identically and each exists to aid in readability. These functions can also be used to measure the length of STL containers like maps and vectors.

The synonymous functions are included to increase readability as while length is intuitive to use for string, it would be more intuitive to refer to an array’s size than its length.

Below we’ll see how to print the length of string str1 with both the length and size functions.

What is a Pointer in C++?#

In C++, all variables must be stored somewhere within the host computer’s memory. To help programs find these variables without searching the memory, C++ allows us to use the special variable, pointers, to explicitly give the variable’s address.

Pointers carry two pieces of information:

The memory address stored as the value of the pointer

The data type indicating the type of variable it points to

Declaring a pointer is similar to declaring a standard variable except that the pointer’s name is preceded by an asterisk.

int *ptr; struct coord *pCrd; void *vp;

Lets see how this can be used below:

First, we initialize two int variables, val1, and val2 as well as an int pointer, mypointer. We then set mypointer to the address of val1 using the & operator. Then the value mypointer points to is set to 10. Since mypointer currently points to the address of val1, this operation changes the value of val1.

We then repeat that process, setting mypointer to the address of val2 and the value at that location to 20.

Pointers have two main advantages in C++: speed and memory use. Using pointers reduces runtime, as programs can access values more quickly when they are given direct memory addresses.

Pointer cheat sheet#

As pointers are one of the more unique elements of C++, it can be tricky to remember all you can do with them. For help, here’s our quick guide on basic pointer syntax:

Syntax Purpose

int *p Declares a pointer p

p = new int Creates an integer variable in dynamic memory and places its address in p

p = new int[5] Creates a dynamic array of size 5 and places the address of its first index in p

p = &var Points p to the var variable

*p Accesses the value of the object p points to

*p = 8 Updates the value of the object p points to

p Accesses the memory address of the object p points to

Syntax	Purpose
`int *p`	Declares a pointer `p`
`p = new int`	Creates an integer variable in dynamic memory and places its address in `p`
`p = new int[5]`	Creates a dynamic array of size 5 and places the address of its first index in `p`
`p = &var`	Points `p` to the `var` variable
`*p`	Accesses the value of the object `p` points to
`*p = 8`	Updates the value of the object `p` points to
`p`	Accesses the memory address of the object `p` points to

What are Arrays in C++?#

C++ arrays are a collection of similar data types stored under the same name. They’re often visualized as a row of i boxes that can be selected by calling the box’s index to access the value held within.

Tip: Array index values begin at 0, meaning the first element in the array would be accessed by calling element 0 rather than 1

The length of an array is set (either explicitly or implicitly) at declaration and cannot change without remaking the array entirely. This, however, makes the array a very memory-efficient structure compared to the vector, as no memory is used after the array is initialized.

#include <iostream>
using namespace std;
int main() {
  int arr[5] = {19, 10, 5, 6, 14}; //initializing the array with 5 values
  cout << "The value of arrr[0], that is, the first value in the array is: " << arr[0] << endl;
  cout<< "The value of arrr[1], that is, the second value in the array is: " << arr[1] << endl;
  cout<< "The value of arrr[2], that is, the third value in the array is: " << arr[2] << endl;
  cout<< "The value of arrr[3], that is, the fourth value in the array is: " << arr[3] << endl;
  cout<< "The value of arrr[4], that is, the fifth value in the array is: " << arr[4] << endl;
  int arr2[] = {1,2,3,4}; //we don't specify the size and the compiler assumes a size of 4
}

Unlike the length function, sizeof actually returns the number of bytes the selected object takes up in memory. The size of each element of an array varies from array to array, so we cannot assume it is only one byte.

To get around this, we use each element within the same array will use the same amount of memory. Therefore, if we divide the total bytes used by the array, sizeof(arr), by the number of bytes used by the first element, sizeof(arr[0]), we get the number of elements in the array.

Another way to find the size is using pointer arithmetic:

What is a Vector in C++?#

C++ vectors are STL containers that act as a more refined version of string arrays. They simplify the process of inserting and deleting values at the cost of using more memory. Vectors store elements in a contiguous manner, so the elements are stored in memory side by side. Unlike arrays, vectors are dynamic, so their size can change on demand and can be traversed using iterators like begin() (for the beginning of the vector) and end() (for the end of the vector).

Vectors are best for situations where you will add or subtract values regularly and memory is largely available.

First, lets see how to use the resize function to activate the vector’s handy dynamic capabilities:

Using C++ Maps#

Maps are a type of container that store elements using key-value pairs. Each element on a map has a unique key as an identifier and a value that is retrieved when the key is called. Keys are automatically sorted smallest to largest, which makes searching maps very quick.

When initialized, both the key and value data types must be set as well as the map object’s name.

Tip: Integers are the most common type of key used with maps; however, they can be other types as well.

The most important functions used with maps are insert(), which adds a new element to the map, and find(), which pulls the element with a corresponding key and returns its value.

Below, we see both of these functions in action with our Employees map:


#include <string.h>  
#include <iostream>  
#include <map>  
#include <utility>  
using namespace std; 
 
int main()  
{
  // Initializing a map with integer keys
  // and corresponding string values
  map<int, string> Employees; 
 
  //Inserting values in map using insert function
  Employees.insert ( std::pair<int, string>(101,"Aaron") );
  Employees.insert ( std::pair<int, string>(102,"Amanda") );
  Employees.insert ( std::pair<int, string>(105,"Ryan") );
 
  // Finding the value corresponding to the key '102'
  std::map<int, string>::iterator it = Employees.find(102);
  if (it != Employees.end()){
    std::cout <<endl<< "Value of key = 102 => " << Employees.find(102)->second << '\n';
  }
}

#include <iostream>
#include <map>
#include <vector>
#include <algorithm> // for sort function
 
using namespace std;
 
// utility comparator function to pass to the sort() module
bool sortByVal(const pair<string, int> &a, 
               const pair<string, int> &b) 
{ 
    return (a.second < b.second); 
} 
 
int main()
{
  // create the map
  map<string, int> mymap = {
    {"coconut", 10}, {"apple", 5}, {"peach", 30}, {"mango", 8}
  };
 
  cout << "The map, sorted by keys, is: " << endl;
  map<string, int> :: iterator it;
  for (it=mymap.begin(); it!=mymap.end(); it++) 
  { 
    cout << it->first << ": " << it->second << endl;
  }
  cout << endl;
 
  // create a empty vector of pairs
  vector<pair<string, int>> vec;
 
  // copy key-value pairs from the map to the vector
  map<string, int> :: iterator it2;
  for (it2=mymap.begin(); it2!=mymap.end(); it2++) 
  {
    vec.push_back(make_pair(it2->first, it2->second));
  }
 
  // // sort the vector by increasing order of its pair's second value
  sort(vec.begin(), vec.end(), sortByVal); 
 
  // print the vector
  cout << "The map, sorted by value is: " << endl;
  for (int i = 0; i < vec.size(); i++)
  {
    cout << vec[i].first << ": " << vec[i].second << endl;
  }
  return 0;
}

Memory Management in C++#

One of the most unique facets of C++ is the need to explicitly allocate heap memory in runtime, a process called dynamic memory allocation. This is handled automatically by the compiler in other languages like Java and JavaScript, giving the programmer less control in favor of ease.

To allocate memory in C++, we use the new operator for a variable and new[] for an array. Each returns the memory address where that data will be stored. We can use this in conjunction with the pointers we discussed earlier to then assign a value to that address.

See how the new operator and pointers are used together below:

// declares an int pointer int* var; // allocate memory for variable // using the new keyword var = new int; // assign value to allocated memory *var = 45;

C++ does not have an automatic garbage collection system, meaning that you must manually deallocate memory from pointers once they’re no longer needed. To do this, we use the delete keyword, which frees up the memory for the given variable or container.

int* var; var = new int; delete var;

If we forget to deallocate memory, we’ll get a memory leak due to unused pointers still holding allocated memory.

main.cpp

myNew.hpp

// myNew.hpp

#ifndef MY_NEW
#define MY_NEW

#include <cstdlib>
#include <iostream>
#include <new>

static std::size_t alloc{0};
static std::size_t dealloc{0};

void* operator new(std::size_t sz){
    alloc+= 1;
    return std::malloc(sz);
}

void operator delete(void* ptr) noexcept{
    dealloc+= 1;
    std::free(ptr);
}

void getInfo(){
    
    std::cout << std::endl;
 
    std::cout << "Number of allocations: " << alloc << std::endl;
    std::cout << "Number of deallocations: " << dealloc << std::endl;
    
    std::cout << std::endl;
}

#endif // MY_NEW

We’ve opted to do this through two separate files for ease of readability, however you could also use a counter variable within the one file if you so wished.

Here we can see that we have 6 allocations but only 4 deallocations, meaning 2 of our pointers are still taking up memory. Though it does not tell us where these rogue pointers are, it does point us in the right direction for if we’ve fully cleaned up after our program.

Attention to memory management is key to being successful as a C++ developer, as larger, complex programs have many more opportunities for mismanaged memory issues. If left unresolved, these issues can slow performance and even cause crashes in the program.

Tip: STL containers and C++ Strings automatically manage their memory allocation, try using more of these to avoid memory leaks or having to micromanage every variable/container.

What to learn next#

Congrats! You’ve now learned some of the intermediate C++ concepts that will make you a proficient and hire-able C++ developer.

As we discussed earlier, C++ is a difficult language to master, even for those with experience in other languages. However, once you get more familiar with its advanced capabilities, you’ll find that C++ grants you an unmatched level of control over often streamlined features like memory allocation.

As you continue your C++ learning journey, here are some advanced topics to check out next:

Smart Pointers

Move and copy semantics

Abstract Base classes

Virtual Methods

Templates

Educative’s C++ from scratch learning path walks you through these advanced topics and more, all with text-based interactive lessons and practice problems. These modules are career-focused, presenting the material you’ll need on the job all written by expert C++ developers.

Continue reading about C++#

C++ is a good first language to learn

A Tutorial on Modern Multithreading and Concurrency in C++

So you know C++. Now it’s time to learn the standard library

Join 2.5 million developers at

Explore the catalog

Free Resources

Learn in-demand tech skills in half the time

PRODUCTS

Mock Interview
New

Courses

Skill Paths

Projects

Assessments

TRENDING TOPICS

Learn to Code

Tech Interview Prep

Generative AI

Data Science

Machine Learning

GitHub Students Scholarship

Early Access Courses

Blind 75

Pricing

For Individuals

Try for Free

Gift a Subscription

CONTRIBUTE

Become an Author

Become an Affiliate

Earn Referral Credits

RESOURCES

Blog

Cheatsheets

Webinars

Answers

ABOUT US

Our Team

Careers
Hiring

Frequently Asked Questions

Contact Us

Press

LEGAL

Privacy Policy

Cookie Policy

Terms of Service

Business Terms of Service

Data Processing Agreement

INTERVIEW PREP COURSES

Grokking the Modern System Design Interview

Grokking the Product Architecture Design Interview

Grokking the Coding Interview Patterns

Machine Learning System Design

Intermediate C++ tutorial: Strings, maps, memory, and more

C++ from Scratch Series#

Why C++ is a good first language to learn#

Beginner’s Guide to C++#

Intermediate C++ Tutorial#

Multithreading and Concurrency in C++#

Top 40 C++ Coding Interview Questions#

Accelerate your C++ learning
Get the knowledge you’ll need to land a C++ job, with 8 modules packed full of hands-on coding practice and lessons designed by developers working in the field today.

Ace the C++ Coding Interview

Using object-oriented programming in C++#

Using Inheritance in C++#

Using Polymorphism in C++#

Abstraction and Encapsulation#

How do Strings work in C++?#

How to print a string#

How to calculate the length of string#

How to concatenate a string#

What is a Pointer in C++?#

Pointer cheat sheet#

What are Arrays in C++?#

How to find the length of an array in C++#

Keep the learning going.#

What is a Vector in C++?#

Using C++ Maps#

How to sort a map by value in C++#

Memory Management in C++#

Tracking allocations and deallocations#

What to learn next#

Continue reading about C++#

Intermediate C++ tutorial: Strings, maps, memory, and more

C++ from Scratch Series#

Why C++ is a good first language to learn#

Beginner’s Guide to C++#

Intermediate C++ Tutorial#

Multithreading and Concurrency in C++#

Top 40 C++ Coding Interview Questions#

Accelerate your C++ learning Get the knowledge you’ll need to land a C++ job, with 8 modules packed full of hands-on coding practice and lessons designed by developers working in the field today. Ace the C++ Coding Interview

Using object-oriented programming in C++#

Using Inheritance in C++#

Using Polymorphism in C++#

Abstraction and Encapsulation#

How do Strings work in C++?#

How to print a string#

How to calculate the length of string#

How to concatenate a string#

What is a Pointer in C++?#

Pointer cheat sheet#

What are Arrays in C++?#

How to find the length of an array in C++#

Keep the learning going.#

What is a Vector in C++?#

Using C++ Maps#

How to sort a map by value in C++#

Memory Management in C++#

Tracking allocations and deallocations#

What to learn next#

Continue reading about C++#

Accelerate your C++ learning
Get the knowledge you’ll need to land a C++ job, with 8 modules packed full of hands-on coding practice and lessons designed by developers working in the field today.

Ace the C++ Coding Interview