Question

How to implement a stack using array that supports items of different type.
e.g. It should operate on characters, integers, floats and doubles.

I have implemented it using void pointers. Below is the C implementation:

void push( void** stack, int* top, void* data, size_t size )
{
    unsigned i;
    ++*top;

    stack[*top] = malloc( size );

    for( i = 0; i < size; ++i )
            ( (char*)stack[*top] )[i] = ( (char*)data )[i];

}

int main()
{
    void* stack[10];
    int top = -1, data = 10;
    char ch = 'a';

    push( stack, &top, (void*)&data, sizeof( int ) );

    push( stack, &top, (void*)&ch, sizeof( char ) );        

    printf( "%d ", *(int*)stack[0] );
    printf( "%c ", *(char*)stack[1] );

    return 0;
}

The code works fine for me.

The problem with the above implementation is that the type of data must be known before-hand.

Does there exists a way to implement it without knowing prior information about type of data to be operated [ I know it is not possible in C, Can we do it in C++, if Yes, How? ]?

Answer 1

If I understand your requirement, you can use boost::any to achieve this in C++.

#include <boost/any.hpp>
#include <vector>

class AnyStack {
    std::vector<boost::any> vec;
public:
    template <class T> void push (const T &e) {
        boost::any v = e;
        vec.push_back(v);
    }
    class Proxy {
        friend class AnyStack;
        std::vector<boost::any> &vec;
        Proxy(std::vector<boost::any> &v) : vec(v) {}
    public:
        template <typename T> operator T () {
            boost::any v = vec.back();
            vec.pop_back();
            return boost::any_cast<T>(v);
        }
    };
    Proxy pop () { return Proxy(vec); }
    boost::any top () { return vec.back(); }
};

As others have suggested, you can use RTTI to determine the type of the item in the stack. The example below demonstrates an output routine that does this.

#include <iostream>
#include <string>

std::ostream & operator << (std::ostream &os, const boost::any &a) {
    if (a.type() == typeid(char)) {
        return os << boost::any_cast<char>(a);
    }
    if (a.type() == typeid(int)) {
        return os << boost::any_cast<int>(a);
    }
    if (a.type() == typeid(float)) {
        return os << boost::any_cast<float>(a);
    }
    if (a.type() == typeid(double)) {
        return os << boost::any_cast<double>(a);
    }
    if (a.type() == typeid(std::string)) {
        return os << boost::any_cast<std::string>(a);
    }
}

int main () {
    AnyStack a;
    a.push(3);
    std::cout << a.top() << std::endl;
    a.push(std::string("hello"));
    std::cout << a.top() << std::endl;
    return 0;
}