Может ли функция бросать смешенные типы данных

int foo(int index)
{
switch(index)
case 1: return 3; break;
case 2: return string answer="0"; break;
case 3: return true; break;
}

#include <iostream>
using namespace std;
 
 
int foo(int index)
{
    switch(index)
    {
    case 1: return 3;
    case 2: throw string("text");
    case 3: throw bool(true); 
    }
    throw logic_error("ololo");
}
 
void example(int index)
{
    try
    {
        const int result = foo(index);
        std::cout << "returned int: '" << result <<"'\n";
    }
    catch(const string& answer)
    {
        std::cout << "returned string: '" << answer <<"'\n";
    }
    catch(bool b)
    {
        std::cout << "returned bool: " 
            << (b? "true" : "false")<<std::endl;
    }
}
 
int main() {
    
    example(1);
    example(2);
    example(3);
    
    return 0;
}

template<class T1, class T2> 
auto gt(T1 х, Т2 у) -> decltype (х + у)
{
    // some code
 
    return х + у; 
}

#include <iostream>
#include <string>
 
template <typename T>
auto foo( T t ) -> decltype( t + t )
{
    return t + t;
}
 
int main()
{
    std::cout << foo(   123  ) << std::endl;
    std::cout << foo(  1.23  ) << std::endl;
    std::cout << foo( std::string( "123" ) ) << std::endl;
}

template <typename T>
T foo();
 
foo<std::string>();
foo<float>();

enum Answer
{
    STRING,
    NUMBER,
};
 
void foo(void*& ptr, const Answer answer);
int main()
{
    void* result = nullptr;
    const Answer choice = STRING;
    foo(result, choice);
    switch(choice)
    {
        case STRING:
        {
                       std::string a = *((std::string*)result);
        }
            break;
    }
}

#include <iostream>
#include <vector>
#include <typeinfo>
 
template <typename T> struct rem_ref      { typedef T type; };
template <typename T> struct rem_ref<T &> { typedef T type; };
 
struct any {
    any() : m_content( 0 ) {}
 
    template <typename T>
    any( const T & value ) : m_content( new holder<T>( value ) ) {}
 
    any( const any & other ) : m_content( other.m_content ? other.m_content->clone() : 0 ) {}
 
    ~any() { delete m_content; }
 
    const std::type_info & type() const {
        return m_content ? m_content->type() : typeid( void );
    }
 
private:
    struct placeholder {
        virtual ~placeholder() {}
        virtual const std::type_info & type() const = 0;
        virtual placeholder * clone() const = 0;
    };
 
    template <typename T>
    struct holder : placeholder {
        holder( const T & value ) : held( value ) {}
        virtual const std::type_info & type() const { return typeid( T ); }
        virtual placeholder * clone() const { return new holder( held ); }
        T held;
    };
 
    placeholder * m_content;
 
    template <typename T> friend T * any_cast( any * );
};
 
template <typename T>
T * any_cast( any * operand ) {
    return operand && operand->type() == typeid( T ) ? & static_cast<any::holder<T> *>(operand->m_content)->held : 0;
}
 
template <typename T>
T * any_cast_ptr_to( any & operand ) {
    return any_cast<typename rem_ref<T>::type>( &operand );
}
 
struct A {
    int val;
    A( int val ) : val( val ) {}
};
 
 
any & foo( int i ) {
    switch ( i ) {
        case 0: return *(new any( 123 ));
        case 1: return *(new any( 12.3 ));
        default: return *(new any( std::string( "123" ) ));
    }
}
 
int main()
{
    for ( int i = 0; i < 3; ++i ) {
        { // int
            int * p = any_cast_ptr_to<int>( foo( i ) );
            if ( p ) {
                std::cout << "int\t\t = " << *p << std::endl;
                continue;
            }
        }
 
        { // double
            double * p = any_cast_ptr_to<double>( foo( i ) );
            if ( p ) {
                std::cout << "double\t\t = " << *p << std::endl;
                continue;
            }
        }
 
        { // std::string
            std::string * p = any_cast_ptr_to<std::string>( foo( i ) );
            if ( p ) {
                std::cout << "std::string\t = " << *p << std::endl;
                continue;
            }
        }
    }
}