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

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

#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;
}

Подойдёт?

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

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

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

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

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

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

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

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

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

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

Если не будет, то можно сделать чтобы типы 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