Пустая базовая оптимизация для лямбда-захватов — запрещена стандартом? Почему?

Из expr.prim.lambda.capture :

Для каждой сущности, захваченной копией, в типе замыкания объявляется безымянный нестатический член данных.

Пока у лямбд здесь нет захвата:

auto f = node{[]{ }}.then([]{ }).then([]{ });

и, следовательно, не имеют безымянных нестатических элементов данных и, следовательно, пусты, это не то, что на самом деле использует then(). Он использует это:

return ::node{[p = std::move(*this), t = std::move(f_then)](){}};

эта лямбда захватывает t и p путем копирования и, следовательно, имеет два безымянных нестатических члена данных. Каждый .then() добавляет еще одну переменную-член, даже если каждая из них пуста, поэтому размер узла продолжает расти.

Или, другими словами, оптимизация пустой базы применяется только к базам, а захват для лямбда-выражений не создает базы, он создает нестатические элементы данных.

У других ответов есть причина, поэтому я не буду повторяться. Я просто добавлю, что мне удалось превратить ваш пример в пример, основанный на наследовании, без лишнего шаблонного кода. Поскольку вы выполняете публичное наследование в OP, я решил удалить c'tor и перейти к агрегатной инициализации.

Потребовалось всего два руководства по дедукции, чтобы сделать код почти таким же красивым, как ваша исходная схема:

Прямая трансляция на Coliru

#include <utility>
#include <iostream>

struct empty {
    void operator()() {}
};

template <typename P, typename T>
struct node : P, T
{
    template <typename FThen>
    auto then(FThen&& f_then)
    {
        return ::node{std::move(*this), std::forward<FThen>(f_then)};
    }

    void operator()() {
        P::operator()();
        T::operator()();
    }
};

template <typename P>             node(P)    -> node<P, ::empty>;
template <typename P, typename T> node(P, T) -> node<P, T>;

int main()
{
    auto f = node{[]{ }}.then([]{ }).then([]{ });
    std::cout << sizeof(f);
}   

EBO был применен, в чем вы можете убедиться, перейдя по ссылке.

Кстати, поскольку мы движемся *this, возможно, стоит уточнить r-значение node::then. Просто чтобы избежать всякой гадости.

Учитывая правило «как если» и [expr.prim.lambda. закрытие]/2:

Реализация может определять тип замыкания иначе, чем описано ниже, при условии, что это не изменяет наблюдаемое поведение программы, кроме изменения:

• размер и/или выравнивание типа укупорочного средства,
• является ли тип закрытия тривиально копируемым (пункт [класс]),
• является ли тип замыкания классом стандартной компоновки (пункт [класс]) или
• является ли тип замыкания классом POD (пункт [класс]).

Я не вижу ничего, что мешало бы реализации использовать какую-то магию для оптимизации хранилища для захваченной пустой переменной.

Тем не менее, это будет перерывом в ЛПИ, так что не задерживайте дыхание.

С другой стороны, разрешение или требование, чтобы реализация делала тип захваченной пустой переменной базой типа замыкания, была бы ужасно плохой идеей. Рассмотреть возможность:

struct X { };
struct Y { };
void meow(X x);                     // #1
void meow(Y y);                     // #2
void meow(std::function<void()> f); // #3

template<class T, class U>
void purr(T t, U u) {
    meow([t = std::move(t), u = std::move(u)] { /* ... */ });
}

Было бы безумием, если бы purr делал что-либо, кроме вызова #3, но если захваты могут стать базами, то он может вызывать #1 или #2 или быть двусмысленным.

Как отмечали другие, лямбда-выражения указываются для захвата как переменных-членов, а не как баз. Так что вам не повезло.

Что вы могли сделать, так это взять страницу из привязки.

Предположим, у вас есть кортеж, который действительно использует пустую базовую оптимизацию. Затем мы можем написать помощник:

template<class Sig>
struct lambda_ebo_t;
template<class F, class...Args>
struct lambda_ebo_t<F(Args...)>:
  private std::tuple<Args...>,
  private F
{
  decltype(auto) operator()(){
    return std::apply( (F&)*this, (std::tuple<Args...>&)*this );
  }
  template<class...Ts>
  lambda_ebo_t( F f, Ts&&...ts ):
    std::tuple<Args...>( std::forward<Ts>(ts)... ),
    F( std::move(f) )
  {}
};

template<class F, class...Args>
lambda_ebo_t<F, std::decay_t<Args>...>
lambda_ebo( F f, Args&&...args ) {
  return {std::move(f), std::forward<Args>(args)...};
}

Это куча шаблонов и неполнота (захват ссылок может работать неправильно, даже если вы используете std::ref), но это дает нам:

template <typename FThen>
auto then(FThen&& f_then)
{
    return ::node{lambda_ebo([](auto&& p, auto&& t)
    {   
    }, std::move(*this), std::move(f_then))};
}

где мы храним данные вне лямбды и передаем их в качестве аргументов лямбде. Хранилище использует EBO.

Нет необходимости писать собственный класс EBO для каждой лямбды, просто несколько обручей, через которые можно пройти, когда вам нужна лямбда с включенным EBO.

Это один без использования кортежа, но он не поддерживает фундаментальные типы, такие как int или другие вещи, из которых вы не можете получить:

template<class Sig>
struct lambda_ebo_t;
template<class F, class...Args>
struct lambda_ebo_t<F(Args...)>:
  private Args...,
//  private std::tuple<Args...>,
  private F
{
  decltype(auto) operator()(){
    //return std::apply( (F&)*this, (std::tuple<Args...>&)*this );
    return ((F&)(*this))((Args&)*this...);
  }
  template<class...Ts>
  lambda_ebo_t( F f, Ts&&...ts ):
    Args(std::forward<Ts>(ts))...,
    F( std::move(f) )
  {}
};

template<class F, class...Args>
lambda_ebo_t<F(std::decay_t<Args>...)>
lambda_ebo( F f, Args&&...args ) {
  return {std::move(f), std::forward<Args>(args)...};
}

Живой пример с этим тестовым кодом:

auto test = lambda_ebo( [](auto&&...args){std::cout << sizeof...(args) << "\n";}, []{} , []{}, []{}, []{}, []{}, []{}, []{}, []{}); //
std::cout << "bytes:" << sizeof(test) << "\n";
std::cout << "args:";
test();

sizeof(test) это 1, и он "захватывает" 8 аргументов.

Пустая базовая оптимизация у меня работает в следующем случае

#include <utility>

template <typename F>
class Something : public F {
public:
    Something(F&& f_in) : F{std::move(f_in)} {}
};

int main() {
    auto something = Something{[]{}};
    static_assert(sizeof(decltype(something)) == 1);
}

Живой пример здесь https://wandbox.org/permlink/J4m4epDUs19kp5CH

Я предполагаю, что причина, по которой это не работает в вашем случае, заключается в том, что лямбда, которую вы используете в методе then(), на самом деле не пуста, она имеет переменные-члены - те, которые перечислены в вашем захвате. Так что настоящей пустой базы там нет.

Если вы измените последнюю строку своего кода, чтобы она просто возвращала node{[]{}}, тогда это сработает. Лямбда-выражения, используемые .then(), не материализуются как "пустые" классы.

Принимая во внимание, что в случае явной структуры у него нет переменных-членов как таковых, только классы, от которых он наследуется, поэтому здесь может работать пустая базовая оптимизация.