Get Value of Void* C++

Question

I have a void pointer and I would like to get the content of what the pointer refers to.

void class :: method(void * pointer)
{
     cout<<pointer; // The address which the pointer refers to.
     cout<<?; //The content of where the pointer refers to.
}  

The original type of pointer is unknown.

EDIT: The goal is to allow create a "generic method" which gets any type of argument, and do the same actions for each. The limitation is that the method is virtual and therefore I cannot use template method.

Answer 1

You need to cast the void* back to its original type (ie. before it was cast to void*). Then you can dereference the pointer and use what it's pointing to.

Eg. :

void fun(void* ptr) {
    int* iptr = (int*) ptr;
    std::cout << *iptr;
}

int* iptr = new int(42);
fun(iptr);

One way to do this in a way that fits your specific use case, is to pass on the type information with the object using a generic type like boost::any :

#include <iostream>
#include <string>
#include <boost/any.hpp>

class Foo {
    public :
    virtual void fun(const boost::any& obj) {
        if (typeid(int) == obj.type()) {
            std::cout << boost::any_cast<int>(obj) << std::endl;
        }
        else if (typeid(std::string) == obj.type()) {
            std::cout << boost::any_cast<std::string>(obj) << std::endl;
        }
        else {
            std::cout << "unsupported type" << std::endl;
        }
    }
};

int main(void) {
    Foo foo;
    int i = 42;
    std::string s = "str";
    float f = 1.1f;
    foo.fun(i);
    foo.fun(s);
    foo.fun(f);
    return 0;   
}

But that can get very verbose, depending on how many types you want to support.

Answer 2

This is impossible. The types in C++ are (mostly) a compile-time property. At runtime, types are unknown (they are erased).

However, RTTI exist, notably for instances of some class containing virtual methods.

There is no possible trick in general. You could redesign your program by having some kind of variant type, or by having a common root class from which all your objects inherit, etc etc, or by using union types (better have your own discriminated unions).

Put it another way: when the compiler see a void* pointer, it does not even know the size of the data pointed by that pointer.

Future C++ standards might propose some std::any container.

Maybe you could have something like a cheap discriminated union class like

class Int_or_String {
   const bool isint;
   union {
     int n;
     std::string s;
   };
   Int_or_String(const int i) : isint(true), n(i) {};
   Int_or_String(const std::string &st): isint(false), s(st) {};
   ~Int_or_String() { if (isint) n=0; else 
     /*not sure*/ s.std::string::~std::string(); };
   // much more is missing
};

^{I'm not even sure of the syntax to explicitly destroy a union member.}

See e.g. this question on calling destructors explicitly

Perhaps the Qt object model might inspire you. Look also into its QVariant

The usual way is to define a root class in your program and adopt the convention that all your objects are inheriting this root class (or even that all your meaningful data are in objects derived from that root class). This requires a redesign of the whole thing.

So you would decide that your root class is e.g

class Root {
public:
  virtual void out(std::ostream&s) =0;
  virtual ~Root() =0;
  /// other common methods
};

static inline std::ostream& operator << (std::ostream&o, const Root &r)
   { r.out(o); return o; }


class Integer : public Root {
   const int num;
 public:
   Integer(int n) : Root(), num(n) {};
   void out (std::ostream &o) { o << num ; }; 
   /// etc...
 }; // end class Num


class String : public Root {
   const std::string str;
 public:
   String(const std::string& s) : Root(), str(s) {};
   void out (std::ostream &o) { o << str ; }; 
   /// etc...
 }; // end class String