Learn about concept in C++ 20

Table of Contents

Introduction concept Defining concept Including a list of constraints User-defined data types Refinement Conclusion

Home/

Blog/

Programming/

Learn about concept in C++ 20

5 mins read

Jan 11, 2024

In this blog, we'll be discussing concept with various examples.

concept#

concept is a new language feature introduced in C++20. It is defined in the <concepts> header. It provides a way to define requirements on template arguments, enabling more concise and readable code. This is achieved by allowing the programmer to specify constraints on the template parameters. These constraints are checked at compile-time without sacrificing type safety. This helps identify errors in templatized code early in the development cycle, improving code reliability.

C++ 17

int main()
{
/*
Integral Types are: 
char , signed char , unsigned char -8 bits
short int , signed short int , and unsigned short int -16 bits
int , signed int , and unsigned int -32 bits
long int , signed long int , and unsigned long int -32 bits (OpenVMS)
long int , signed long int , and unsigned long int -64 bits (Digital UNIX)
signed __int64 (Alpha) and unsigned __int64 (Alpha)-64 bits
enum -32 bits
*/
    std::cout<<"The sum of two integers is "<< Add(10, 20)<<"\n";
    std::cout<<"The sum of two 8 bit characters converted to ASCII is "<< Add('a', 'b')<<"\n";
    //Following line will generate an error as floating point is not an integral value.
//    std::cout<<"The sum of two doubles is "<< Add(10.2, 20.3)<<"\n";  
    return 0;
}

C++

struct Rational 
{
    int Numerator;
    int Denominator;
    
    Rational operator + (const Rational & rhs) const 
    {
        return {Numerator * rhs.Denominator + Denominator * rhs.Numerator, Denominator * rhs.Denominator};
    }
};
template <>
struct std::common_type<Rational> 
{
    using type = Rational;
};
int main()
{
    Rational num1 {1, 2};
    Rational num2 {1, 3};
    Rational result = Sum (num1, num2);
    std::cout <<"The sum of two rational numbers is "<< result.Numerator << "/" << result.Denominator <<"\n"; 
    // Output: The sum of two rational numbers is 5/6
    std::cout<<"The sum of two integers is "<< Sum(10, 20)<<"\n";
    // Output: The sum of two integers is 30
    std::cout<<"The sum of two doubles is "<< Sum(10.5, 20.9)<<"\n";
    // Output: The sum of two doubles is 31.4
    return 0;
}

In lines 1–10, a user-defined type Rational representing a rational number has been defined. The + operator in lines 6–9 that satisfies the requirements of the Addable concept has been implemented in the structure. Finally, a std::common_type specialization has been provided to specify that the common type of two Rational objects is also Rational. In the main function, two objects of type Rational have been created and initialized. The Sum function has been called using these two objects. The function calls the overloaded + operator and returns the result of the addition, which is stored in another result object and displayed on the console. Moreover, two examples of primitive datatypes, int and double, have also been provided to elaborate on the use of concept. As the concept of the + operator has been defined in this example, the concept can be used to ensure the availability of other operators for different data types.

Let's take another example where concept can be used for refinement. In the following code, a Range has been defined that requires the type T to implement begin and end functions that return an iterator of the same type.

In line 3, a vector has been defined and initialized. In line 4, the print_range function has been called to print the vector. The output is as desired. However, when lines 6–7 are uncommented, an error is generated at compile-time, indicating that no matching function exists for the int array because it doesn't have begin and end functions. This saves any runtime error that may have caused the termination of an execution.

Conclusion#

In short, concept provides a more readable and maintainable way to define constraints on template parameters. It makes it easier to express the requirements of a template argument and to write generic code that works with a wide range of types.

We hope that this blog has not only triggered your quest to learn more about C++ 20 but also inspired you to learn to code in C++ with greater depth. For further readings please continue with the following courses:

C++ Concepts: Improve Type Safety with C++ 20 is all about using concept for type safety.

The All-in-One Guide to C++20 introduces C++20 in great detail.

C++ Fundamentals for Professionals is for refreshing C++.