struct T { int a, b; };
T t = {.a = 1, .b=42};

void f(int a, int b);

f(.a = 1, .b=42);

PM>Мое скромное мнение — это синтаксический оверхед

void addElement(T, bool replace);

enum ReplaceOrNot {
  Replace, DontReplace
};
void addElement2(T, ReplaceOrNot replace);

addElement(1, false);
addElement2(1, Replace);

addElement(1, .replace=true); // также понятно, как и addElement2, но нет оверхеда с созданием enum

// да, можно сделать два метода - addElement(T), addOrReplaceElement(T) - но если булевых аргументов два - то делать четыре?
// да, можно аргументы метода передавать в виде структуры. Можно даже изобрести объект-метод addElement(1).replace(false)()
// но все это обход недостатка языка...

HWND WINAPI CreateWindow(
  _In_opt_  LPCTSTR lpClassName,
  _In_opt_  LPCTSTR lpWindowName,
  _In_      DWORD dwStyle,
  _In_      int x,
  _In_      int y,
  _In_      int nWidth,
  _In_      int nHeight,
  _In_opt_  HWND hWndParent,
  _In_opt_  HMENU hMenu,
  _In_opt_  HINSTANCE hInstance,
  _In_opt_  LPVOID lpParam
);

ATOM WINAPI RegisterClass(
  _In_  const WNDCLASS *lpWndClass
);

typedef struct tagWNDCLASS {
  UINT      style;
  WNDPROC   lpfnWndProc;
  int       cbClsExtra;
  int       cbWndExtra;
  HINSTANCE hInstance;
  HICON     hIcon;
  HCURSOR   hCursor;
  HBRUSH    hbrBackground;
  LPCTSTR   lpszMenuName;
  LPCTSTR   lpszClassName;
} WNDCLASS, *PWNDCLASS;

/// a.cpp
struct T {
  std::string s;
} a;

/// b.cpp
struct T {
  int q;
  std::string s;
} b;

//a.cpp
void f(int, int); // определение где-то в другом месте: в другом файле или либе

void g()
{
  f(4, 5);  
}

E>void f(int a, int b);
E>f(.a = 1, .b=42);
E>

const int a = 1;
const int b = 42;
f(a, b);

inline void LastAnswerOnUltimateQuestion()
{
  const int nAnswerNumber = 1;
  const int nAnswerValue  = 1;
  f(nAnswerNumber, nAnswerValue);
}

// foo.h
void foo(int a, int b);

//foo.cpp
void foo( int /* a */, int /* b */ )
{
   // а и b  не используются, поэтому, в определении их закоментировали, чтобы избежать предупреждения компилятора.
}

void funct(explicit int int_param, explicit double float_param);

funct(.int_param = 5, .float_param = 0.7); // ok
funct(5, 0.5); // compile error

foo(FooArgs{ .a = 1, .b = 42 })

[set_a: 1 b: 42] /* void set_a:b: (int, int) - или что-то типа того */

x and y                          -- Bool.and(y)
x and: y and: z                  -- Bool.and:and:(y,z)
x and: y and: z and: t           -- Bool.and:and:and:(y,z,t)
x and: y and: z and: t and: u    -- Bool.and:and:and:(y,z,t,u)

int f(int);

int f(int x) { return x + 1; }

inf f(int x);

int f(int) { return 42; }

E>/// a.cpp
E>struct T {
E>  std::string s;
E>} a;

E>/// b.cpp
E>struct T {
E>  int q;
E>  std::string s;
E>} b;
E>

C>// foo.h
C>void foo(int a, int b);

C>//foo.cpp
C>void foo( int /* a */, int /* b */ )
C>{
C>   // а и b  не используются, поэтому, в определении их закоментировали, чтобы избежать предупреждения компилятора.
C>}
C>

void foo(int a, int b);

void foo(int c, int d) {

}


foo(.a=1, .b=2); // вот тут уже однозначно ошибка компиляции

struct T { 
  int a, b; 
  T(int a, int b) : a(a), b(b) {}
};
T t = {.a = 1, .b=42};

BOOST_PARAMETER_NAME(graph)    // Note: no semicolon
BOOST_PARAMETER_NAME(visitor)
BOOST_PARAMETER_NAME(root_vertex)
BOOST_PARAMETER_NAME(index_map)
BOOST_PARAMETER_NAME(color_map)

BOOST_PARAMETER_FUNCTION(
      (void),                // 1. parenthesized return type
      depth_first_search,    // 2. name of the function template

      tag,                   // 3. namespace of tag types

      (required (graph, *) ) // 4. one required parameter, and

      (optional              //    four optional parameters, with defaults
        (visitor,           *, boost::dfs_visitor<>())
        (root_vertex,       *, *vertices(graph).first)
        (index_map,         *, get(boost::vertex_index,graph))
        (in_out(color_map), *,
          default_color_map(num_vertices(graph), index_map) )
      )
  )
  {
      // ... body of function goes here...
      // use graph, visitor, index_map, and color_map
  }

     SendAnswer(.nAnswerNumber = 1, .nAnswerPriority = 42, .nAnswerValue = 42);

     SendAnswer(
                .nAnswerNumber   = 1,
                .nAnswerPriority = 42,
                .nAnswerValue    = 42
               );

f(1_a, 42_b);
SendAnswer(1_answer_number, 2_answer_priority, 42_answer_value);

BFE>>Вы сами так пишите,

Автор: enji
Дата: 11.09.14

только вместо локальных констант используете enum.

void addElement(T, bool replace);

enum ReplaceOrNot {
  Replace, DontReplace
};
void addElement2(T, ReplaceOrNot replace);

typedef bool ReplaceOnAdd;
void addElement3(T, bool replace);

addElement3(1, ReplaceOnAdd(true));

PM>typedef bool ReplaceOnAdd;
PM>void addElement3(T, bool replace);

PM>addElement3(1, ReplaceOnAdd(true));
PM>

addElement3(1, ReplaceOnAdd = true);

void foo(int a, int b);
...
void foo(int b, int a) { // ой, у вас ус отклеился...
}

class A
{
  public:
    virtual void f(int a) {};
};


class B : public A
{
  public:
    virtual void f(int b) {};
};

  A* p = new B;
  p->f(.a = 1);

//a.cpp
void f(int a, int b); // определение где-то в другом месте: в другом файле или либе
void f(int b, int a);

void g()
{
  f(.a = 4, .b = 5); //line (1)
}

BFE>  A* p = new B;
  p->>f(.a = 1);
BFE>

Данная штука ведет себя примерно так же, как и параметры по умолчанию — т.е. разворачивается компилятором в обычный вызов функции сразу в месте вызова с той информацией, которая там компилятору доступна.

  A* p = new B;
  p->f(.a = 1);

  B* p = new B;
  p->f(.a = 1);

void f (int a);
void f (int);

void f(int b) { }

f(.b =1);

BFE>С суффиксами это тоже видно. И стандарт менять не надо.

BFE>>С суффиксами это тоже видно. И стандарт менять не надо.

long double operator "" _w(long double);
std::string operator "" _w(const char16_t*, size_t);
unsigned operator "" _w(const char*);
int main()
{
  1.2_w; // calls operator "" _w(1.2L)
  u"one"_w; // calls operator "" _w(u"one", 3)
  12_w; // calls operator "" _w("12")
  "two"_w; // error: no applicable literal operator
}

static struct platform_device iq8134x_flash = {
    .name           = "physmap-flash",
    .id             = 0,
    .dev            = { .platform_data  = &iq8134x_flash_data, },
    .num_resources  = 1,
    .resource       = &iq8134x_flash_resource,
};