Добрый день! Не могу разобраться как аккуратно сделать обработку одной штуки:
1) есть библиотека B-сплайнов в Eigen, в которой по-разному нужно обрабатывать сплайны разных размерностей (1D, 2D)
2) Услово есть два файла с 1D сплайном и 2D, причём первый содержит 2 столбца, а второй - три.

Нужно придумать аккуратную структуру или ещё что-то, что подаётся в кастомный интерфейс (с eigen), который бы обрабатывал сплайны. Идеи такие:

struct Spline2d
{
  ...
  ...
  ...
}
struct Spline1d
{
  ...
  ...
}

auto MySpline = Spline1d{{123, 0.0}, {345, 0.5}, {678, 0.9}};
auto m_splineFromFile = MySpline;
std::optional<BSpline> BSpline::initialize(const std::variant<Spline1d, Spline2d>& m_splineFromFile)

А уже внутри BSpline::initialize аккуратно "вскрывать" m_splineFromFile через try { std::get<Spline1d>(); }, catch { ...std::get<Spline2d>(); } Но звучит так себе, да.
В итоге хотелось бы как-то удачно разделить задачи "зачитывание параметров" и "инициализация сплайна", чтобы первую выполнял пользователь, а второй - разработчик интерфейса

Это... неожиданно https://godbolt.org/z/5dj7sj

void foo(int&& x){}

int main(int argc, char *argv[])
{
 float x = 1.0f;
 foo(x);
}

Это компилируется

а почему неожиданно? в g идет материализация rvalue, без std::move он теряет свое свойство

void foo(int&& x){}

int main(int argc, char *argv[])
{
 float x = 1.0f;
 foo(x);
}

да, но ИМХО ппц как не логично. даже goto что вчера обсуждали в супе прям джуна можно спросить что происходит. а тут, единицы понимают

А кто-то понимает? Объясните мне тогда

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

я вроде уловил, что первая подстановка в лоб дает фэйл. дальше получается остается одна перегрузка (не та что нужна) и компилятор такой хммм ну это лучше чем ничего и подставляет ее.

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

В моём примере нет перегрузки.

ну значит я тоже не понял этой фигни. мой вопрос который я задал первым, почему срезка типа из float в int законна. мне сказали что я лох. :(

Ну такое сужающее преобразование законно, но тут, мне кажется, сломалась система типов просто

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

Чего ломалось то?
f(int&&)

Вызов
float arg;
f(arg);
эквивалентен
f(int(arg));

тогда почему если сунуть флоат, что более корректно ошибка компиляции?

давай упростим:

void f(float&&) {
    puts("float");
}
void f(int&&) {
    puts("int");
}
void g(auto&& v) {
    f(v); // здесь v материализуется и уже не rvalue
}
int main() { 
    f(1);
    f(1.0f);
    g(1);
    g(1.0f);
}

кажется что если ты пишешь общий случай ты будешь использовать перфект форвардинг и оно не должно поломаться

Здесь выполняется два преобразования, в целом. Lvalue-to-rvalue и float-integer. Как минимум обычно выполняется максимум одно

void f(float&&) {
    puts("float");
}
void f(int&&) {
    puts("int");
}
void g(auto&& v) {
    f(v); // здесь v материализуется и уже не rvalue
}
int main() { 
    f(1);
    f(1.0f);
    g(1);
    g(1.0f);
}

почему матерелизуется в не правильный тип?

стоп, int&& материализуется в int&, float&& в float &