Designated Initializers: Finally in C++20

Designated initializers let you name the members of a struct during initialization in a way that’s checked by the compiler. To see why this is helpful, consider the following example where I accidentally swapped two parameters in the constructor:

Preventing bugs

#include <iostream>

struct Config {
    int timeout;
    int retries;
    bool verbose;
};

int main() {
    Config cfg{30, false, 1};
    std::cout << "Config: timeout=" << cfg.timeout 
              << ", retries=" << cfg.retries 
              << ", verbose=" << std::boolalpha << cfg.verbose << "\n";
    return 0;
}

Godbolt Output

Config: timeout=30, retries=0, verbose=true

Believe it or not, this compiles with no warnings on GCC 15.2! false is implicitly converted to 0, and 1 is implicitly converted to true, so the swapping of retries with verbose isn’t caught.

If we had written Config cfg{.timeout=30, .verbose=false, .retries=1}, the compiler would initialize the struct correctly or trigger a compilation error depending on whether we were in C or C++.

Basic Syntax

#include <iostream>
#include <string>

struct Person {
  std::string name;
  int age;
  double height;
};

int main() {
  Person person{
      .name = "Alice",
      .age = 28,
      .height = 1.65
  };

  std::cout << person.name << " is " << person.age 
            << " years old and " << person.height << "m tall\n";
  return 0;
}

Partial Initialization

We can also use designated initializers to do partial initialization:

#include <iostream>

struct Settings {
    int volume;           // guaranteed to be 0 if partially initialized
    int brightness = 100; // default value
    bool darkMode = true; // default value
};

int main() {
    // Only override brightness, keep defaults for others
    Settings s{.brightness = 75};
    
    std::cout << "Settings: volume=" << s.volume 
              << ", brightness=" << s.brightness 
              << ", darkMode=" << std::boolalpha << s.darkMode << "\n";
    return 0;
}

Godbolt Output

Settings: volume=0, brightness=75, darkMode=true

If a struct member doesn’t have a default, it’ll be zero-initialized.

#include <iostream>
#include <string>

struct NetworkConfig {
  std::string host = "localhost";
  int port = 80;
  int timeout = 30;
  bool ssl = true;
};

int main() {
  // Designated initializers zero-initialize unspecified members!
  NetworkConfig config{.port = 8080};

  std::cout << "Host: " << config.host << "\n";
  std::cout << "Port: " << config.port << "\n";
  std::cout << "Timeout: " << config.timeout << "\n";
  std::cout << "SSL: " << std::boolalpha << config.ssl << "\n";
  return 0;
}

Limitations

In C++ specifically, designated initializers must be written in order of the struct members. We also can’t use designated initialization with user-provided constructors, virtual base classes, or non-public member variables.

class Widget {
    int value;            // private - can't use designated init
public:
    Widget(int v);        // user-provided constructor
};

Widget w{.value = 42};    // Won't compile

struct Point {
    int x;
    int y;
};

Point p{.y = 2, .x = 1};  // Won't compile in C++, will compile in C

Fun in C

C’s designated initializers are more interesting. Aside from working in any order, nested initialization and array initialization are also acceptable.

#include <stdio.h>

struct Point {
    int x;
    int y;
};

struct Window {
    struct Point origin;
    int width;
    int height;
};

int main(void) {
    // Nested designated initializers - valid C, invalid C++
    struct Window w = {
        .origin.y = 7, // Out of order!
        .origin.x = 6,
        .width = 67,
        .height = 76
    };
    
    printf("Window: (%d, %d) size %dx%d\n", 
           w.origin.x, w.origin.y, w.width, w.height);

    // Array initialization
    int 🫲🥴🫱[10] = {[6] = 7}; // Unicode variable names????
    printf("🫲🥴🫱[6] = %d", 🫲🥴🫱[6]);

    return 0;
}

Godbolt Output

Window: (6, 7) size 67x76
🫲🥴🫱[6] = 7

Let’s try C out!

#include <stdio.h>

struct Color {
  int r;
  int g;
  int b;
};

int main(void) {
  // Array designators: [index] = value
  int values[10] = {
      [9] = 300, // The order doesn't matter in C
      [2] = 100,
      [5] = 200
  };

  // Nested designators: [index].member = value
  struct Color colors[3] = {
      [1].g = 255,
      [0].r = 255,
      [2].b = 255
  };

  // Print values array
  printf("values: [");
  for(int i = 0; i < 10; i++) {
      printf("%d%s", values[i], i < 9 ? ", " : "]\n");
  }
  
  // Print colors
  for(int i = 0; i < 3; i++) {
      printf("colors[%d] = (%d, %d, %d)\n", 
             i, colors[i].r, colors[i].g, colors[i].b);
  }
  return 0;
}

Got questions or cool use cases? Find me on LinkedIn!