Understanding Specialized Containers in C++

A homogeneous container guarantees one shared element type. A heterogeneous container deliberately gives up that guarantee in exchange for allowing mixed types.

Programming

A Shelf With One Question

A container is a structure that holds several values together. Once you start working with containers, an important question comes up: are all of the values inside a container required to be of the same kind? The answer separates containers into two families, heterogeneous containers and homogeneous containers. Knowing which family a container belongs to tells you what kinds of values it can store, and that determines how you can use it.

Think of a shelf where every item must be the same kind of object, such as all books. Now imagine a shelf where you are allowed to place a book, a cup, and a pencil side by side. The first shelf enforces a single kind of item. The second accepts mixed kinds. Containers in programming behave in the same two ways, and the two behaviors have their own names.

Notice that the question to ask about any container is not how many values it holds, but what kinds of values it is permitted to hold together. Keep that central question in mind as you read: does this container allow its elements to differ in type, or does it require them to match?

What do you think happens?

Can a single container hold both the integer 7 and the string 'seven' at the same time?

Yes, every container can hold mixed types
No, no container can hold mixed types
It depends on which container it is

Reveal answer

Answer:

It depends on which container it is.

The source identifies pair and tuple as heterogeneous containers, which can hold elements of different types. All other containers are homogeneous, meaning every element shares one type. So the answer depends on the family the container belongs to.

Heterogeneous Containers and Mixed Element Types

Definition

A heterogeneous container can hold elements of different data types. Its defining feature is freedom in the element types: it is not restricted to one kind of value, so its elements may come from different types.

This freedom is the property that sets pair and tuple apart from the rest of the containers the source discusses. When you see a heterogeneous container, you should expect that its positions can hold values of different kinds.

cpp

#include <iostream>
#include <string>
#include <utility>

int main() {
    std::pair<int, std::string> item{7, "seven"};
    std::cout << item.first << " " << item.second << "\n";
    return 0;
}

#include <iostream>
#include <string>
#include <utility>

int main() {
    std::pair<int, std::string> item{7, "seven"};
    std::cout << item.first << " " << item.second << "\n";
    return 0;
}

Output

7 seven

Notes on the code

std::pair is named in the source as a heterogeneous container
The first element is an int and the second element is a std::string

Tuple Positions and Their Own Types

Pair and tuple are both named by the source as heterogeneous. A tuple can hold more than two elements, and each position in it keeps its own element type. The diagram below traces one tuple whose three positions hold an int, a string, and a double. Each position maps to exactly one type and one value.

cpp

#include <iostream>
#include <string>
#include <tuple>

int main() {
    std::tuple<int, std::string, double> record{7, "seven", 3.5};
    std::cout << std::get<0>(record) << " "
              << std::get<1>(record) << " "
              << std::get<2>(record) << "\n";
    return 0;
}

#include <iostream>
#include <string>
#include <tuple>

int main() {
    std::tuple<int, std::string, double> record{7, "seven", 3.5};
    std::cout << std::get<0>(record) << " "
              << std::get<1>(record) << " "
              << std::get<2>(record) << "\n";
    return 0;
}

Output

7 seven 3.5

Notes on the code

Position 0 holds an int
Position 1 holds a std::string
Position 2 holds a double

How does each position in a tuple map to its own element type and value?

Read the diagram from left to right. Each box is one position in the tuple. The label names the position, and the sublabel shows the element's type followed by its value. The three boxes do not share a type, which is exactly what makes the tuple heterogeneous.

Homogeneous Containers and the Single-Type Rule

Definition

A homogeneous container holds elements that all share the same data type. The rule is strict but simple: every element in a homogeneous container shares one type.

When you read or write code that uses a homogeneous container, you can rely on this fact. Every element you pull out has the same type as the others, which is why this family is described as uniform. You never have to ask what kind of value a given element is, because the container has already settled that question for you.

cpp

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers{3, 1, 4};
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << "\n";
    return 0;
}

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers{3, 1, 4};
    for (int n : numbers) {
        std::cout << n << " ";
    }
    std::cout << "\n";
    return 0;
}

Output

3 1 4

Notes on the code

Every element of this container is an int
The loop can treat each element as an int because the single-type rule guarantees it

Key point

A homogeneous container guarantees one shared element type. A heterogeneous container deliberately gives up that guarantee in exchange for allowing mixed types.

Comparing the Two Families

The two families are opposites on one property: whether element types may differ. The diagram groups containers by that single property. Once you know whether a container permits mixed element types, you know which family it belongs to.

How does a container that enforces a single element type differ from one that holds elements of several types, and which one does each example fall into?

Property	Heterogeneous	Homogeneous
Element types	May differ from one element to another	All share one data type
Source examples	pair and tuple	All other containers
What you can rely on	Each position may have its own type	Every element has the same type

Classifying a container by whether its element types may differ

Assuming Every Container Mixes Types

The most common error is to assume that every container can hold mixed element types. The same two values, an int and a string, behave differently depending on the container you choose. The before and after view below shows that a single-type container cannot take both, while a pair or tuple can.

Before

std::vector<int> values{7, "seven"};

A homogeneous container asked to hold an int and a string together, which breaks the single-type rule

After

std::pair<int, std::string> values{7, "seven"};

A heterogeneous container holding an int and a string, each in its own position

Common mistake
Assuming every container can mix element types
What it looks like
Trying to store 7 and 'seven' together in a container that only allows one type
Why it fails
Only heterogeneous containers such as pair and tuple are allowed to hold elements of different types. All other containers are homogeneous and require one shared type.
Do this instead
Before placing mixed values in a container, check whether it is heterogeneous. If it is not, choose pair or tuple, or store the values in another way that respects the single-type rule.
Common mistake
Judging a container by how many values it holds
Why it fails
The source asks us to focus on what kinds of values a container may hold together, not on how many values it contains.
Do this instead
Ask whether the container allows its elements to differ in type. The count does not decide the family.

Classifying Containers on Sight

To classify a container quickly, hold up the central question: may its elements differ in type? If the answer is yes, the container is heterogeneous. If every element must share one type, it is homogeneous. Apply this test to the containers below before you check the reasoning.

EASY

Classify each container as heterogeneous or homogeneous: (1) pair, (2) tuple, (3) a container where every element must be an int. Explain your reasoning in terms of whether element types may differ.

Hints

The source names pair and tuple as the heterogeneous containers.
The source says all other containers are homogeneous.
A container whose elements must all be int has one shared type.

Your attempt (not saved)

MEDIUM

You need to store a student's name as a string, age as an int, and grade as a double in one object. Decide which family of container fits, and justify your choice using the single-type rule and the freedom of element types.

Hints

Ask whether the three values share one type.
Consider which family permits elements of different types.

Your attempt (not saved)

Key Takeaways

A heterogeneous container can hold elements of different data types, and the source identifies pair and tuple as its examples.
A homogeneous container holds elements that all share the same data type, following a strict single-type rule.
Classify any container by asking whether its elements may differ in type, not by how many values it holds.
Do not assume every container can mix element types; only heterogeneous containers allow it.

Related concepts

Introduction to C++ Data Types

More concepts starting with U

A Shelf With One Question

Heterogeneous Containers and Mixed Element Types

Tuple Positions and Their Own Types

Homogeneous Containers and the Single-Type Rule

Comparing the Two Families

Assuming Every Container Mixes Types

Classifying Containers on Sight

Key Takeaways

Related Topics

Related concepts