.CPP File Format – Declarations

Specifiers

simple-declaration:
    decl-specifier-seq [init-declarator-list] ;

init-declarator:
    declarator [initializer]

A declaration has a sequence of specifiers, then a list of declarators, each of which names one entity [dcl.spec]. int* a, b; declares a pointer a and an int b, because the * belongs to the declarator.

typedef unsigned long ulong_t;       // C-style alias
using ulong2 = unsigned long;        // alias-declaration (C++11)

template<class T>
using Ptr = T*;                      // alias template: typedef cannot do this

Declarators

A declarator gives a name and modifies the type from the specifiers [dcl.decl], [dcl.meaning].

A declarator is read from the name outwards, with suffixes binding tighter than prefixes:

int  x;               // int
int* p;               // pointer to int
int  a[3];            // array of 3 int
int* b[3];            // array of 3 pointers to int
int  (*c)[3];         // pointer to array of 3 int
int  f(int);          // function taking int, returning int
int  (*g)(int);       // pointer to function taking int, returning int
int  (&h)(int) = f;   // reference to function
int* (*k[2])(int);    // array of 2 pointers to function returning int*
int  C::*m;           // pointer to int member of C
int  (C::*n)(int);    // pointer to member function of C

Widget a();          // declares a function a, not an object
Widget b{};          // an object, value-initialised
Widget c(Widget());  // declares a function c taking a function pointer
Widget d{Widget()};  // an object

Initialisation

C++ has several forms of initialisation, chosen by syntax [dcl.init].

Reading an object with an indeterminate value is undefined behaviour, with narrow exceptions for unsigned char and std::byte.

std::vector<int> a(3, 5);   // three elements, each 5
std::vector<int> b{3, 5};   // two elements: 3 and 5

int n{3.14};                // error: narrowing
int m(3.14);                // allowed: m is 3

struct Point { int x; int y = 7; };

Point a{1, 2};            // x = 1, y = 2
Point b{1};               // x = 1, y = 7 (default member initialiser)
Point c{.x = 1, .y = 2};  // designated initialisers (C++20)
Point d(1, 2);            // parenthesised aggregate initialisation (C++20)

int v[3] = {1, 2};        // v[2] is zero-initialised
int w[] = {1, 2, 3};      // the bound is deduced: int[3]

Structured bindings

A structured binding (C++17) declares several names that refer to parts of one object [dcl.struct.bind]. A hidden variable e holds the initialiser, and each name refers to one element or member of it.

attribute-specifier-seq? decl-specifier-seq ref-qualifier? [ identifier-list ] initializer ;

initializer:  = expression  |  { expression }  |  ( expression )

In this form the square brackets are literal, and ? marks the optional parts.

std::map<std::string, int> counts;
for (auto& [key, value] : counts)     // references to the pair's members
    value += 1;

auto [first, second] = std::pair{1, 2.0};

struct Point { int x; int y; };
const auto [x, y] = Point{1, 2};      // x and y are const

int arr[2] = {1, 2};
auto& [a, b] = arr;                   // a and b alias arr's elements

auto is required. The qualifiers and reference applied to it affect the hidden variable, not the names directly. A structured binding cannot be constexpr in C++23 and, before C++20, could not be captured by a lambda.

constexpr, consteval and constinit

constexpr int square(int n) { return n * n; }
constexpr int a = square(4);           // evaluated at compile time

consteval int cube(int n) { return n * n * n; }
int b = cube(3);                       // the call must be constant

constinit int counter = 0;             // no dynamic initialisation
void bump() { ++counter; }             // not const

void f() {
    if consteval {                     // C++23
        /* compile-time path */
    } else {
        /* run-time path */
    }
}

What constexpr functions may contain has grown over time.

A constant expression is one that the compiler can evaluate entirely during translation, without undefined behaviour [expr.const]. An expression with undefined behaviour is not a constant expression, so constant evaluation can detect it.

Attributes

An attribute has the form [[name]] or [[ns::name(args)]] [dcl.attr]. A compiler ignores attributes it does not recognise, except that an unknown attribute may cause a warning. [[using ns: a, b]] (C++17) shares a namespace between several attributes.

alignas looks like an attribute but is a keyword with its own grammar [dcl.align].

Language linkage

A linkage specification sets the language linkage of function and variable names [dcl.link]. Implementations must support "C" and "C++", and other strings are conditionally supported. A header usually guards this for use from both languages.

#ifdef __cplusplus
extern "C" {
#endif

int c_function(int value);

#ifdef __cplusplus
}
#endif

Elsewhere in a declaration, asm("text") is a conditionally supported way to embed assembly language [dcl.asm].