A tuple is an object that can hold a number of elements. The elements can be of different data types. The elements of tuples are initialized as arguments in order in which they will be accessed. Tuples are a versatile data structure for grouping values. To understand how to use tuples in C++ and their applications, the C++ Course provides comprehensive tutorials and examples.
Operations on Tuple
1. get(): get() is used to access the tuple values and modify them, it accepts the index and tuple name as arguments to access a particular tuple element.
2. make_tuple(): make_tuple() is used to assign tuple with values. The values passed should be in order with the values declared in tuple.
CPP
#include <iostream>
#include <tuple>
using namespace std;
int main() {
// Declaring tuple
tuple<char, int, float> geek;
// Assigning values to tuple using make_tuple()
geek = make_tuple('a', 10, 15.5);
// Printing initial tuple values using get()
cout << "The initial values of tuple are: ";
cout << get<0>(geek) << " " << get<1>(geek);
cout << " " << get<2>(geek) << endl;
// Use of get() to change values of tuple
get<0>(geek) = 'b';
get<2>(geek) = 20.5;
// Printing modified tuple values
cout << "The modified values of tuple are: ";
cout << get<0>(geek) << " " << get<1>(geek);
cout << " " << get<2>(geek) << endl;
return 0;
}
OutputThe initial values of tuple are: a 10 15.5
The modified values of tuple are: b 10 20.5
Explanation: In the above code, get() modifies the 1st and 3rd value of tuple.
3. tuple_size: It returns the number of elements present in the tuple.
CPP
#include <iostream>
#include <tuple>
using namespace std;
int main() {
// Initializing tuple
tuple<char, int, float> geek(20, 'g', 17.5);
// Use of size to find tuple_size of tuple
cout << "The size of tuple is: ";
cout << tuple_size<decltype(geek)>::value;
return 0;
}
OutputThe size of tuple is: 3
4. swap(): The swap(), swaps the elements of the two different tuples.
CPP
#include <iostream>
#include <tuple>
using namespace std;
int main() {
// Initializing 1st tuple
tuple<int, char, float> tup1(20, 'g', 17.5);
// Initializing 2nd tuple
tuple<int, char, float> tup2(10, 'f', 15.5);
// Printing 1st and 2nd tuple before swapping
cout << "The first tuple elements before swapping are: ";
cout << get<0>(tup1) << " " << get<1>(tup1) << " " << get<2>(tup1) << endl;
cout << "The second tuple elements before swapping are: ";
cout << get<0>(tup2) << " " << get<1>(tup2) << " " << get<2>(tup2) << endl;
// Swapping tup1 values with tup2
tup1.swap(tup2);
// Printing 1st and 2nd tuple after swapping
cout << "The first tuple elements after swapping are: ";
cout << get<0>(tup1) << " " << get<1>(tup1) << " " << get<2>(tup1) << endl;
cout << "The second tuple elements after swapping are: ";
cout << get<0>(tup2) << " " << get<1>(tup2) << " " << get<2>(tup2) << endl;
return 0;
}
Output
The first tuple elements before swapping are: 20 g 17.5
The second tuple elements before swapping are: 10 f 15.5
The first tuple elements after swapping are: 10 f 15.5
The second tuple elements after swapping are: 20 g 17.5
5. tie(): The work of tie() is to unpack the tuple values into separate variables. There are two variants of tie(), with and without "ignore" , the "ignore" ignores a particular tuple element and stops it from getting unpacked.
CPP
#include <iostream>
#include <tuple> // for tie() and tuple
using namespace std;
int main() {
// Initializing variables for unpacking
int i_val;
char ch_val;
float f_val;
// Initializing tuple
tuple<int, char, float> tup1(20, 'g', 17.5);
// Use of tie() without ignore
tie(i_val, ch_val, f_val) = tup1;
// Displaying unpacked tuple elements without ignore
cout << "The unpacked tuple values (without ignore) are: ";
cout << i_val << " " << ch_val << " " << f_val;
cout << endl;
// Use of tie() with ignore
// ignores char value
tie(i_val, ignore, f_val) = tup1;
// Displaying unpacked tuple elements with ignore
cout << "The unpacked tuple values (with ignore) are: ";
cout << i_val << " " << f_val;
cout << endl;
return 0;
}
OutputThe unpacked tuple values (without ignore) are: 20 g 17.5
The unpacked tuple values (with ignore) are: 20 17.5
6. tuple_cat(): This function concatenates two tuples and returns a new tuple.
CPP
#include <iostream>
#include <tuple> // for tuple_cat() and tuple
using namespace std;
int main() {
// Initializing 1st tuple
tuple<int, char, float> tup1(20, 'g', 17.5);
// Initializing 2nd tuple
tuple<int, char, float> tup2(30, 'f', 10.5);
// Concatenating 2 tuples to return a new tuple
auto tup3 = tuple_cat(tup1, tup2);
// Displaying new tuple elements
cout << "The new tuple elements in order are: ";
cout << get<0>(tup3) << " " << get<1>(tup3) << " "
<< get<2>(tup3) << " " << get<3>(tup3) << " "
<< get<4>(tup3) << " " << get<5>(tup3) << endl;
return 0;
}
OutputThe new tuple elements in order are: 20 g 17.5 30 f 10.5
Similar Reads
Structures in C++ C++ Structures are used to create user defined data types which are used to store group of items of different data types.SyntaxBefore using structure, we have to first define the structure using the struct keyword as shown:C++struct name{ type1 mem1; type2 mem2; ... };where structure name is name an
8 min read
Operators in C++ C++ operators are the symbols that operate on values to perform specific mathematical or logical computations on given values. They are the foundation of any programming language.Example:C++#include <iostream> using namespace std; int main() { int a = 10 + 20; cout << a; return 0; }Outpu
9 min read
Strings in C++ In C++, strings are sequences of characters that are used to store words and text. They are also used to store data, such as numbers and other types of information in the form of text. Strings are provided by <string> header file in the form of std::string class.Creating a StringBefore using s
5 min read
find() in C++ STL C++ find() is a built-in function used to find the first occurrence of an element in the given range. It works with any container that supports iterators, such as arrays, vectors, lists, and more. In this article, we will learn about find() function in C++.C++#include <bits/stdc++.h> using nam
2 min read
List in C++ STL In C++, list container implements a doubly linked list in which each element contains the address of next and previous element in the list. It stores data in non-contiguous memory, hence providing fast insertion and deletion once the position of the element is known.Example:C++#include <iostream
7 min read