Question

Write a short \(\mathrm{C}++\) program that creates a Pair class that can store two objects declared as generic types. Demonstrate this program by creating and printing Pair objects that contain five different kinds of pairs, such as < int,string > and < float,long >.

Short answer

Include headers, define Pair class template, add print function, create Pair objects in main and print them.

Step-by-step solution

Include Necessary Headers

Start by including the necessary header files for input-output operations and template support. Use `#include ` for standard input-output streams.

Define the Pair Class Template

Define a template class `Pair` that can hold two generic types `T1` and `T2`. Use the template syntax `template `. Within the class, declare two private members for storing the two objects and define a constructor to initialize these members.

Add Print Function

Inside the Pair class, add a member function to print the values of the two objects. This function should use the standard `std::cout` for output.

Create Main Function

In the `main` function, create instances of the Pair class with different type combinations such as ``, ``, etc. Initialize these instances with appropriate values.

Print Pair Objects

Call the print function for each Pair object to display their values.

Compile and Run

Compile the program using a C++ compiler and run the executable to see the output of the Pair objects.

Key concepts

C++ Templates

C++ templates are a powerful feature allowing functions and classes to operate with generic types. This enables code reuse and flexibility. Instead of writing multiple versions of a function or class for different data types, a template allows you to write it once and use it with any type. For example, you define a template using the `template ` syntax. Here, `T1` and `T2` are placeholders for data types that will be specified when an object of the template class is instantiated. This approach is core to the exercise, as it allows the Pair class to store any combination of two data types.

Generic Programming

Generic programming aims to write code that works with any data type, reducing duplication and improving code maintainability. By using templates, C++ supports generic programming, meaning you can write a function or class that works with any data type. Imagine writing different versions of a Pair class for each data type: `Pair`, `Pair`, etc. With generic programming, you only need to write the Pair class template once, and it can handle any combination of types. This is particularly useful in large codebases where maintaining multiple versions of similar code can be cumbersome.

Class Definitions

Defining a class in C++ involves specifying its data members and member functions. In the Pair class template, you use `template ` to declare the class. Within the class, private data members are used to store the values of the two objects. The constructor initializes these members, and a print function is defined to output their values. This encapsulation of data and behavior within a class adheres to the principles of object-oriented programming, ensuring that data is managed in a structured way.

Iostream Usage

The iostream library in C++ provides classes for input and output operations, including `std::cout` and `std::cin` for standard output and input. In the Pair class template example, `std::cout` is used within the print function to display the values of the objects. You include the iostream library at the beginning of your program with `#include `, enabling these operations. Using `std::cout`, you can print text and variables to the console, making it essential for debugging and displaying results.

Object-Oriented Programming

Object-oriented programming (OOP) is a paradigm centered around objects that contain data and methods. In the Pair class template, OOP principles are used to define a class with private data members and public functions. Encapsulation ensures that the internal state of objects is protected. The class template itself is a blueprint for creating Pair objects, allowing you to instantiate pairs of different types easily. By using constructors for initialization and member functions for behavior, the Pair class demonstrates key OOP concepts, focusing on the interaction between data and methods.