Variadic templates и list initialization

Напиши конструктор, который будет брать по три аргумента и передавать их в конструктор структуры.

В смысле, конструктор структуры с тремя аргументами написать? Да писал я такой, не работает, естественно.

Забей. Я плохо понял, что ты хочешь. Попробуй вот так

Baz<Foo>({"q",10,20},{"g",11,50});

Я добавил явное указание типа для шаблона.

deductions guide ему нужен вместо этого.

Зачем тебе шаблон, если ты передаешь только Foo?

auto Baz(Foo&& foo, Foo&&... t) {

Не проверял.

Вообще я почти уверен, что твой fold expression не сработает. Посмотри примеры с вектором тут: https://en.cppreference.com/w/cpp/language/fold.

Вместо move() лучше использовать forward().

С двумя аргументами работает, с тремя уже нет, надо писать Baz<Foo,Foo>.

move там потому, что структура Foo определена как приватная в классе, и объекты этого типа снаружи класса создавать нельзя, внутри Baz не нужна. Отсюда и заморочки эти с list initialization. Вообще, задача состоит в том, чтобы передать в функцию произвольное число групп из от одного до трёх параметров, недостающие параметры принимают значения по умолчанию. Если б не эти умолчания, можно было бы просто написать шаблон

Baz(const std:string& s, size_t b, size_t e, T&&... t)

и не париться.

Можешь представить полный код?

Вот более подробная структура: https://gcc.godbolt.org/z/Ysq5T8v7P

И что мешает тебе сделать так (это я про использование forward()):

  template <class... T>
  auto Baz(struct Foo&& foo, T&&... t) const {
    return PrivateBaz(std::vector<struct Foo>(
        {std::forward<Foo>(foo), std::forward<T>(t)...}));
  }

Если у тебя есть публичный интерфейс в виде функции:

template<class... T>
auto Baz(struct Foo&& foo, T&&... t)

То делать объявление Foo (которое является частью этого публичного интерфейса) приватным - это как чесать правое ухо мизинцем левой ноги стоя на голове. Не?

А нахрена его делать публичным, если единственный способ использовать Foo снаружи - это передать его Baz? Ну, и допустим, будет он публичным, задачу сделать компактный интерфейс Baz это не решает никак, писать struct Foo f{«f»,1,2},g{«g»,2}, потом Baz(f,g) мне не кажется удобным. Структура Foo сама по себе никому не сдалась, это просто способ передать параметры.

Первая конструкция не работает по той же причине, что и вторая, невыводим тип {«g», 11, 50}. Либо явно указывать Baz, либо создавать функцию Baz(Foo&&,Foo&&). При увеличении количества аргументов повторить. Мне, кроме Baz(std::vector&&) и дополнительных фигурных скобок в вызове ничего толкового для общего случая в голову не приходит.

Первая конструкция не работает по той же причине, что и вторая, невыводим тип {«g», 11, 50}

Я это и написал.

Мне, кроме Baz(std::vector&&) и дополнительных фигурных скобок в вызове ничего толкового для общего случая в голову не приходит.

std::vector тяжеловат для этого. Может лучше использовать std::initializer_list?

А чем initializer_list будет легче в данном контексте? Вектор создаётся один раз, дальше только правой ссылкой передаётся, элементы вектора конструируются при его создании, вроде, никаких накладных расходов нет?

https://stackoverflow.com/a/27753670

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

А, без new/delete.

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

Например так использовать уже не получится:

s.Baz(Something::Foo{"q", 10, 20});

// или так:
Something::Foo f{"q", 10, 20};
s.Baz(std::move(f));

Хотя это две валидных конструкции для человека, который смотрит на интерфейс функции Baz(). И потом так думаешь: а какого хера так нельзя. Только потому, что автор решил разрешить только такую конструкцию:

s.Baz({"q", 10, 20});

Вот только из initializer_list нельзя ничего переместить, так как он всегда константный. А ТС хочет перемещать, т.е. вектор как раз логичнее.

struct Foo f{«f»,1,2},g{«g»,2}, потом Baz(f,g) мне не кажется удобным

Почему не сделать так?

Baz(Foo{ "f",1,2 },
    Foo{ "g",1,2 });

Так я как раз и хочу избавиться от этих ненужных букв

Может тогда скопировать интерфейс QStringList?

Baz(Foos() << { "f",1,2 } << { "g",1,2 });

Подойдёт и другой лево-ассоциативный оператор. Можно от явного вызова Foos() избавиться:

Baz(Foo{ "f",1,2 } << { "g",1,2 });

А это идея. Можно заменить Baz на оператор, всё равно это функция-член класса. Сложности только с реализацией будут, мне надо все параметры обработать за раз, то есть оператор «<<» будет запоминать аргументы, а для их обработки придётся добавить что-то типа std::endl в конце.

Тут соглашусь.

Ты не считаешь, что это программирование ради программирования?

Неужели это не проще и яснее:

Baz(Foo{ "f",1,2 }, Foo{ "g",1,2 });

Да, так и есть ) Просто хочется, чтобы было красиво, а красиво, значит лаконично и без лишних сущностей )

Такое:

#include <array>
#include <string>
#include <iostream>

struct Foo
{
 std::string s;
 size_t b,e;
};

template<std::size_t sz>
auto Baz(std::array<Foo, sz> args)
{
	for (auto &a : args)
		std::cout << a.s << std::endl;
	return 0;
}

#define call_bas(sz, first, ...) \
Baz(std::array<Foo, sz>{ Foo first __VA_OPT__(,) __VA_ARGS__})


int main()
{
	call_bas(2, {"first", 4, 2}, {"second", 6, 2});
	return 0;
}

Правда от размер не удалось избавиться (а может полезно - передавать дефолтносозданные объекты?). Пробовал через std::experimental::make_array - не вышло.

Еще можно попробовать завернуть в tuple чтобы не плодить Foo.

Хотя вот здесь предлагают решение для подсчета аргументов в VA_AGRS, поэтому если слиьно хочется, то будет как заказывал:

call_bas( {"first", 4, 2}, {"second", 6, 2} );

О, как интересно. Про variadic macros я не то, чтобы не знал, но в жизни бы не догадался посмотреть в их сторону.

P.S. Меня восхищает логика людей, придумавших variadic macros, и не создавших нормального способа подсчёта количества аргументов.

ЦПП сила )

#include <array>
#include <string>
#include <iostream>
#include <tuple>

struct Foo
{
 std::string s;
 size_t b,e;
};

template<std::size_t sz>
auto Baz(std::array<Foo, sz> args)
{
	std::cout << "cnt = " <<  args.size() << std::endl;
	for (auto &a : args)
		std::cout << a.s << std::endl;
	return 0;
}

consteval int args_cnt(const char *str)
{
	int ret = 0;
	for (;  *str != '\0';  ++ str)
		if (*str == '}')
			++ ret;
	return ret;
}

#define call_baz(first, ...) \
Baz(std::array<Foo, args_cnt(#__VA_ARGS__)>{ Foo first __VA_OPT__(,) __VA_ARGS__})

int main()
{
	call_baz( {"first", 4, 2}, {"second", 6, 2}, {"third", 6, 2} );
	return 0;
}

Это не сила. Это венегрет из ребусов кто напишет более по-китайски.

Использовать такое, конечно, не стоит, самому же потом читать это. Но решение, сочетающее сишные макросы с последним плюсовым стандартом, не лишено определённого очарования. Месье знает толк в извращениях )

Месье знает толк в извращениях

Во-во.

Вы лучше гляньте как народ раньше кол-во аргументов считал ), более того - многие способы не подходят, тут сложный случай с запятыми в скобках, да и сам скобки. А новые фичи очень элегантно вписываются. Кстати, макрос сокращается до такого:

#define call_baz(...) \
  Baz(std::array<Foo, args_cnt(#__VA_ARGS__)>{ Foo __VA_ARGS__})

Ну не знаю, по-моему вполне симпатично, я на шаблонах писал в тысячу раз более лютый венегрет.

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

А еще, работая в одной конторе на крупном комерческом проекте, видел как с помощью макросов делали объявление переменной некоторого типа:

some_type_decl(var_name)

Мне тут стало интересно и я посмотрел по комитам, кто этот гений, так выснилось - тимлид. Ну бля, ну тимлид.

Вспоминал я тут наше это обсуждение и вот к чему пришел. Если использовать сразу std::initializer_list - то будет конечно копирование, когда начнешь доставать значения из std::initializer_list и присваивать их далее. Но эй, ведь если будешь использовать функцию, принимающую аргумент вида std::vector<A>&& и будешь передавать список инициализации - то все равно будет использоваться конструктор std::vector(std::initializer_list<T>) т.е. при этом все равно будет сразу создаваться объект std::initializer_list с переданными значениями и далее уже из него эти значения будут скопированы в std::vector, т.е. один фиг копирование будет.

Вот иллюстрация написанного:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

struct A {
    A() { cout << "A()" << endl; }
    A(const string& n) : name(n) { cout << "A(const string&)" << endl; }
    A(const A& a) : name(a.name) { cout << "A(const A&)" << endl; }
    A(A&& a) : name(move(a.name)) { cout << "A(A&&)" << endl; }

    ~A() { cout << "~A()" << endl; }

    A& operator=(const A& a) {
        cout << "operator=(const A&)" << endl;
        name = a.name;
        return *this;
    }

    A& operator=(A&& a) {
        cout << "operator=(A&&)" << endl;
        name = move(a.name);
        return *this;
    }

    string name;
};

void f(vector<A>&& args) {
    cout << "void f(vector<A>&& args)" << endl;
    // do something
}

// void f(initializer_list<A> args) {
//     cout << "void f(initializer_list<A> args)" << endl;
//     // do something
// }

int main() { f({{"first"}, {"second"}, {"third"}}); }

Вывод:

A(const string&)
A(const string&)
A(const string&)
A(const A&)
A(const A&)
A(const A&)
~A()
~A()
~A()
~A()
~A()
~A()

Таким образом все же использование std::vector получается избыточным и добавляет некоторые минимальные накладные расходы.

Но эй, ведь если будешь использовать функцию, принимающую аргумент вида std::vector<A>&& и будешь передавать список инициализации - то все равно будет использоваться конструктор std::vector(std::initializer_list<T>)

Блин, точно.

Я немного наврал с выводом: там еще должна быть строка:

void f(vector<A>&& args)

Должно быть так:

A(const string&)
A(const string&)
A(const string&)
A(const A&)
A(const A&)
A(const A&)
void f(vector<A>&& args)
~A()
~A()
~A()
~A()
~A()
~A()