Key words

Understanding Keywords in C++

Keywords are reserved words in C++ that have a predefined meaning in the language. These words cannot be used as identifiers (like variable names, function names, or class names) because they serve a special purpose within the language’s syntax. C++ is a rich, complex language, and its keywords define the core structure of the language, such as data types, control structures, and object-oriented programming concepts.

In this article, we’ll explore the most important C++ keywords, breaking them down into categories for clarity.

Complete List of C++ Keywords

The following is a complete list of reserved keywords in the C++ language. These keywords were introduced in C++ and are currently part of the language's syntax. They cannot be used as identifiers (variable names, function names, etc.).

The keywords are divided into groups based on the C++ version in which they were introduced:

• C++98 (and earlier) contains the keywords available from the beginning.
• C++11 introduces a significant number of new keywords.
• C++14 and C++17 do not introduce any new keywords.
• C++20 introduces a few new keywords for concepts and coroutines.

Keywords in C++98 (and earlier)

and, and_eq, asm, auto, bitand, bitor, break, case, catch, char, class, compl, const, const_cast, continue, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, not, not_eq, operator, or, or_eq, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while, xor, xor_eq

Keywords in C++11

alignas, alignof, auto, constexpr, decltype, delete, nullptr, noexcept, static_assert, thread_local

Keywords in C++14

No new keywords were introduced in C++14.

Keywords in C++17

No new keywords were introduced in C++17.

Keywords in C++20

concept, co_await, co_return, co_yield, requires

Keywords in C++23

explicit (for template parameters), false (for the `constexpr` context), pattern (for matching syntax), and others based on the evolving C++23 standard.

Keywords in C++26 (anticipated)

As of now, the C++26 standard is still in development, and specific keywords are not finalized. However, potential future keywords might relate to new features around concepts, pattern matching, or other extensions to language features.

1. Control Flow Keywords

Control flow keywords help manage the execution flow of programs. These keywords determine how loops, conditionals, and function execution are handled in C++ programs.

• if: Used to make decisions based on conditions. The if statement executes a block of code only if the specified condition is true.

  if (x > 0) {
      // do something
  }
  

• else: Follows an if statement and provides an alternative block of code to execute if the condition is false.

  if (x > 0) {
      // do something
  } else {
      // do something else
  }
  

• switch: Used for multi-way branching, allowing you to execute different blocks of code depending on the value of a variable.

  switch (x) {
      case 1:
          // do something
          break;
      case 2:
          // do something else
          break;
      default:
          // default case
          break;
  }
  

• case, default: Used within a switch block to define specific cases and a default case if none of the cases match.

• for, while, do: These keywords define looping constructs:

 * for: Iterates over a range of values.
   

    for (int i = 0; i < 10; ++i) {
        // loop body
    }
    

 * while: Repeats a block of code while a condition is true.
   

    while (x < 10) {
        // loop body
    }
    

 * do: Similar to while, but ensures the loop body is executed at least once.
   

    do {
        // loop body
    } while (x < 10);
    

• break: Exits from a loop or switch statement early.

  while (true) {
      if (x == 5) {
          break; // exit the loop
      }
  }
  

• continue: Skips the current iteration of a loop and proceeds with the next iteration.

  for (int i = 0; i < 10; ++i) {
      if (i == 5) {
          continue; // skip the rest of the loop when i is 5
      }
  }
  

2. Data Type Keywords

Data type keywords define the type of data that can be stored in variables. C++ offers both built-in primitive types and user-defined types, but these keywords are used for the built-in ones.

• int: Represents an integer data type.

  int x = 5;
  

• char: Represents a single character.

  char c = 'A';
  

• float, double: Used for floating-point numbers (single and double precision).

  float f = 3.14f;
  double d = 3.14159;
  

• bool: Represents a boolean value (true or false).

  bool flag = true;
  

• void: Indicates a function does not return a value or specifies an empty type for pointers.

  void function() {
      // no return value
  }
  

3. Storage Class Keywords

Storage class keywords define the scope, lifetime, and visibility of variables and functions.

• static: Used to declare variables that persist across function calls or limit the visibility of a variable to the current translation unit.

  static int count = 0; // persists across function calls
  

• extern: Declares variables or functions that are defined in another file.

  extern int count; // count is defined elsewhere
  

• register: Suggests that the variable be stored in a CPU register for faster access (modern compilers often ignore this).

  register int count;
  

• mutable: Allows a member of a const object to be modified.

  class MyClass {
  public:
      mutable int x;
  };
  

4. Object-Oriented Programming Keywords

C++ is an object-oriented language, and these keywords define various object-oriented constructs.

• class: Declares a class, which is a blueprint for creating objects.

  class MyClass {
  public:
      int x;
      void display() {
          std::cout << x << std::endl;
      }
  };
  

• struct: Declares a structure, similar to a class, but with public members by default.

  struct MyStruct {
      int x;
  };
  

• public, private, protected: Access modifiers that define the accessibility of class members.

  class MyClass {
  private:
      int x;
  public:
      void setX(int val) {
          x = val;
      }
  };
  

• virtual: Used to declare a virtual function, enabling dynamic polymorphism.

  virtual void display();
  

• override: Used in derived classes to indicate a function overrides a base class method.

  void display() override;
  

• new, delete: Used for dynamic memory allocation and deallocation.

  int* p = new int(5);  // allocate memory
  delete p;             // free memory
  

• this: Refers to the current instance of the class.

  class MyClass {
  public:
      void print() {
          std::cout << this << std::endl;  // address of the current object
      }
  };
  

• friend: Allows a non-member function or class to access the private and protected members of a class.

  class MyClass {
  private:
      int x;
  public:
      friend void show(MyClass&);
  };
  

5. Other Keywords

These keywords serve various purposes throughout the language.

• return: Used to return a value from a function.

  return 5;
  

• const: Declares constant values or variables that cannot be changed after initialization.

  const int x = 10;
  

• sizeof: Returns the size (in bytes) of a variable or data type.

  std::cout << sizeof(int);  // output the size of an int
  

• typeid: Used for runtime type identification.

  typeid(x).name();
  

• namespace: Defines a scope that can contain identifiers (like variables, functions, or classes) to avoid name conflicts.

  namespace MyNamespace {
      int x = 5;
  }
  

• template: Used to define a generic class or function.

  template <typename T>
  T add(T a, T b) {
      return a + b;
  }
  

Conclusion

C++ keywords form the foundation of the language’s syntax and control structures. Understanding these keywords is essential for writing correct and efficient C++ programs. From managing control flow to defining data types and implementing object-oriented principles, the variety of keywords enables a flexible and powerful programming environment. As you continue learning and practicing C++, you’ll encounter more advanced uses of these keywords, including templates, lambda functions, and type inference.