С++. Зависимость возвращаемого функцией типа от значения ее параметра?

Question

[iasonov]

Здравствуйте.


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

Если да, то как?


Поясняющий пример: функция с одним параметром int должна возвращать значение типа double, если параметр == 1, либо значение типа bool, если параметр == 2.


Погуглив, нашел что-то по теме, да не то:

• decltype
  
• auto
  

Comments

[iasonov]

Мне надо возвращать различные наборы параметров в зависимости от считанного из файла значения.
В итоге решил возвращать не различные типы (структуры, в моем случае), а класс свойств, унаследованный от std::map.

Answer 1

[megalol]

#include "boost/variant.hpp"

boost::variant<int, std::string > f(int i)
{
if (i == 0)
{
return 1;
}
else
{
return std::string("str");
}
}

int main()
{
std::cout << f(0) << " " << f(1) << std::endl;
}


Comments

[iasonov]

Правильно ли я понимаю, что значения f(0) & f(1) в данном случае вычисляются на этапе компиляции (т.е. решение в чем-то аналогично решению выше)?

[megalol]

Нет, variant — динамический, можно 0 и 1 по командам юзера передавать. Как он устроен внутри отдельная история — насколько я помню, перегружается оператор приведения типа.

[iasonov]

Отлично, спасибо! Буду пробовать.

[Андрей Кравчук]

Нет, неправильно, f(0) и f(1) вычисляются в runtime.

Answer 2

[Dzuba]

Нельзя.
Причина: тип возвращаемого значения определяется на этапе компиляции, а не во время выполнения. Следовательно: не может зависеть от значения параметра метода.

Answer 3

[CorporateShark]

#include <iostream>

template <int I> struct i
{
	enum { value = I };
};

double Func( i<1> P )
{
	return 3.14159;
}

<code>
bool Func( i<2> P )
{
	return false;
}

template <int I> std::string Func( i<I> P )
{
	return "Something else";
}

int main()
{
	std::cout << Func( i<1>() );
	std::cout << std::endl;
	std::cout << Func( i<2>() );
	std::cout << std::endl;
	std::cout << Func( i<3>() );

	return 0;
}

Подойдёт?

Comments

[Dzuba]

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

Answer 4

[Akson87]

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

Comments

[iasonov]

Спасибо, но данный подход не хочется внедрять ввиду его некрасивости/запутанности в обработке. Хотелось сделать get, который будет возвращать различные типы в зависимости от свойства объекта, но, насколько я понял, так сделать не получится ввиду строгой типизации в C++

Answer 5

[Yaraife]

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

void* f(int i){
int array[i];
return (void*)array;
}

int main(){
int * array2 = (int*)f(5);
return 0;
}

Но вообще это плохо. Очень плохо :)
Типы были придуманы именно для таких ситуаций.
Конечно, можно работать с данными, выбирая тип по своему желанию, но это увеличивает шанс ошибки.

Comments

[megalol]

Вы возвращаете ссылку на убитый стековый объект.

[iasonov]

Согласен с megalol: надо бы динамически выделять в данном случае память…
Пробовал имплементировать данное решение. Понял, что не подходит по следующей принципиальной причине: некрасивость/запутанность обработки. Хотелось сделать get, который будет возвращать различные типы в зависимости от свойства объекта, но, насколько я понял, так сделать не получится ввиду строгой типизации в C++

[Yaraife]

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

Давно сам присматриваюсь к бусту.

Answer 6

[agmt]

На С++ можно сделать что угодно. Вот только задающий этот вопрос, мне кажется, сам не до конца понял, что ему надо (не в обиду). Можно в eax пихнуть перед возвратом что угодно. На его уровне типов нет. Вот только что будет происходит в месте вызова функции? Как он будет разбираться, что ему вернули?
Да и без контекста тоже не понятно, для чего это нужно.

P.S. а предложить могу возвращать строку, которая будет представлять собой XML, например=) В таком случае решение о типе действительно будет приниматься на этапе выполнения.
P.P.S. интересно, почему никто не предложил union?

Answer 7

[Adam_Ether]

Может и можно, но делать так не надо.
Подумайте как в Вашем случае может быть использована перезагрузка функции или использование параметров по умолчанию. И, возможно, вопрос отпадет сам собой.

Answer 8

[burdakovd]

Определитесь, вызывающая сторона будет знать на этапе компиляции объект какого типа ей нужно получить?

Если будет, то сделайте переключающий параметр параметром шаблона, как предлагал .

Если не будет, то можно сделать чтобы типы A и B реализовывали общий интерфейс I. В интерфейсе описать все методы, которые вызывающая сторона требует от этих типов.
И возвращать из функции указатель на I.

Типа

class I {
    // interface
    // ...
    virtual ~I() {}
};

class A: public I { ... }
class B: public I { ... }

I* foo(const int sw) {
    return sw == 0 ? new A(...) : new B(...);
}

Разумеется можно возвращать не сырой указатель, а unique_ptr