c ++ 11 — пересылка определения типа decl — C ++ 11

Question

c ++ 11 — пересылка определения типа decl — C ++ 11

Я хотел бы использовать decltype виртуально связать возвращаемый тип метода с типом переменной, подобной этой

#include <iostream>

decltype(a) foo()                     // my point
{
return 4.3f;
}

int main(int argc, char* argv[])
{
auto a = 5.5f;
std::cout << foo() << std::endl;
return(0);
}

но этот код не компилируется под g++-4.7.2 на Linux, как вы можете легко догадаться.

Есть ли обходной путь для этого? я знаю auto но это не то, что я хотел бы использовать (я не хочу использовать auto для возвращаемого типа foo())

0

c++c++11 decltype g++

Решение

Другие решения

Вы можете использовать шаблоны

template <typename T>
T foo()
{
return 4.3f;
}

и позвонить, используя foo<float>()

Вы также можете использовать decltype если a объявляется перед функцией, вот так:

auto a = 5.3f;

decltype(a) foo()
{
return 4.3f;
}

2

С C ++ 1y вы сможете сделать это:

#include <iostream>

auto foo()
{
return 4.3f;
}

int main(int argc, char* argv[])
{
auto a = 5.5f;
std::cout << foo() << std::endl;
return(0);
}

что вы уже можете сделать с лямбда-функциями.

Это реализовано в g ++ — 4.8 с флагом std = c ++ 1y.

Я ответил здесь: C ++ 11 авто и возвращаемые функции

1

Это то, что вы после? Это должно скомпилировать:

#include <iostream>

const float foo()
{
return 4.3f;
}

int main(int argc, char* argv[])
{
decltype(foo()) a;
a = foo();
std::cout << a << std::endl;
return(0);
}

0

Источник

Accepted Answer

Какова именно ваша цель здесь? Можно ли передать переменную в функцию? Если нет, как функция должна знать, какой тип использовать? Если вы согласны с передачей переменной в функцию, вы можете использовать шаблон:

template<typename T>
T foo(T) {
return 4.3f;
}

Теперь вы можете назвать это как

std::cout << foo(a) << std::endl;

Переменная здесь используется только для получения ее типа. Если вы не хотите передавать переменную, вам нужно предоставить тип напрямую, например,

template<typename T>
T foo() {
return 4.3f;
}

std::cout << foo<decltype(a)>() << std::endl;

Но это, конечно, довольно некрасиво.

Теперь, если вы хотите использовать макросы, вы можете немного упростить это:

template<typename T>
T _foo() {
return 4.3f;
}
#define foo() _foo<decltype(a)>()

std::cout << foo() << endl;

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

Фундаментальный вопрос здесь заключается в том, что функция не может неявно использовать тип переменной, так как функция объявляется первой. Таким образом, если шаблоны не являются хорошим решением, тогда единственная альтернатива — объявить тип где-нибудь, чтобы и функция, и переменная могли получить к нему доступ. Это может быть достигнуто с typedef:

typedef float atype;

atype foo() {
return 4.3f;
}

int main() {
atype a = 5.5f;
std::cout << foo() << std::endl;
}

Кроме того, вы можете просто решить, что возвращаемое значение foo() считается авторитетом по рассматриваемому типу:

float foo() {
return 4.3f;
}

int main() {
decltype(foo()) a = 5.5f;
std::cout << foo() << std::endl;
}

1