Why avoid friends, or how I lost all my advantages

Hello, Habr.

A couple of days ago I came across this tweet:

In short: once again in C ++ they found some kind of crap that appeared there itself, emergent-convergent, like slime from one short science fiction story I read in my childhood, which accidentally arose in urban sewers and grew into a universal organic solvent.

Let's figure it out, since it will not be long (according to the text of the Standard I jumped no more than a couple of hours). And fun, links to Standard are always fun.

Here is the whole code:

#include <cstdio>

class tag;

template<class>
struct type { friend constexpr auto get(type); };

template<class TKey, class TValue>
struct set { friend constexpr auto get(TKey) { return TValue{}; } };

void foo() {            // never called
  if constexpr(false) { // never true
    if (false) {        // never true
        constexpr auto call = [](auto value) { std::printf("called %d", value); };
        void(set<type<tag>, decltype(call)>{});
    }
  }
}

int main() {
  get(type<tag>{})(42); // prints called 42
}

.

class tag;

, .

template<class>
struct type { friend constexpr auto get(type); };

type. , get - .

, (13.9.1/1) type<T> T? ( , argument-dependent lookup, !) get(T) (9.8.1.2/3, 13.9.1/4), (6.2/2.1).

template<class TKey, class TValue>
struct set { friend constexpr auto get(TKey) { return TValue{}; } };

set. , , get - .

, set<K, V> K, V? get(K), (6.2/2).

void foo() {
  if constexpr(false) {
    if (false) {
        constexpr auto call = [](auto value) { std::printf("called %d", value); };
        void(set<type<tag>, decltype(call)>{});
    }
  }
}

, if (false) , , :

void foo() {
  if constexpr(false) {
    constexpr auto call = [](auto value) { std::printf("called %d", value); };
    set<type<tag>, decltype(call)>{};
  }
}

, if constexpr , . ?

if constexpr : 8.5.1/2. :

If the value of the converted condition is false, the first substatement is a discarded statement

, call set — discarded statement. .

:

During the instantiation of an enclosing templated entity, if the condition is not value-dependent after its instantiation, the discarded substatement (if any) is not instantiated.

discarded statement, , . false, , value-dependent, «». «enclosing template entity», enclosing entity — foo, . , , , if constexpr .

. , type<tag>, get(type<tag>) , ADL, get type<tag> ( 9.8.1.2/3). set<type<tag>, decltype(call)>, get(type<tag>), type<tag>. decltype(call), call , C++20 (7.5.5.1/13), . main get(type<tag>{}), get ADL. , call, , 42.

.

, — discarded statement enclosing template entity. , void foo() template<typename> void foo(),

#include <cstdio>

class tag;

template<class>
struct type { friend constexpr auto get(type); };

template<class TKey, class TValue>
struct set { friend constexpr auto get(TKey) { return TValue{}; } };

template<typename>
void foo() {
  if constexpr(false) { // never true
    if (false) {        // never true
        constexpr auto call = [](auto value) { std::printf("called %d", value); };
        void(set<type<tag>, decltype(call)>{});
    }
  }
}

int main() {
  foo<int>();
  get(type<tag>{})(42); // prints called 42
}

:

prog.cc:23:3: error: function 'get' with deduced return type cannot be used before it is defined
  get(type<tag>{})(42); // prints called 42
  ^
prog.cc:6:37: note: 'get' declared here
struct type { friend constexpr auto get(type); };
                                    ^

, C++ - — , ( -), ( SFINAE, detector idiom ). , - C++?

, , C++. , — , - . — - , , - - template , . , , chaotic evil. — , , , , .

, . - C++14, C++11, 03.

? :

Defining a friend function in a template, then referencing that function later provides a means of capturing and retrieving metaprogramming state. This technique is arcane and should be made ill-formed.
Notes from the May, 2015 meeting:
CWG agreed that such techniques should be ill-formed, although the mechanism for prohibiting them is as yet undetermined.

, — , .

, !