打印出未知类型变量的值？

Question

I'm trying to write a simple function template in C++ in which I am printing out the value of a variable of unknown type. The problem is I can't figure out how to do this since the variable could either be a pointer or a primitive type. With the primitive type, I can simply print the value out; but pointers require de-referencing.

The following code gives me an error:

#include <iostream>
#include <type_traits>

using namespace std;

template<typename T>
void foo(T someVar) {
  if(std::is_fundamental<T>::value) {
    cout << "It's primitive! \n" << someVar << endl;
  } else {
    cout << "It's a pointer! \n" << *someVar << endl;
  }
}

int main(int argc, char **argv) {
  int x = 5;
  foo(x);

  int *y = new int();
  *y = 5;

  foo(y);
  delete y;

  return 0;
}

The error I get when I compile is:

test.cc: In function 'void foo(T) [with T = int]':
test.cc:19:8:   instantiated from here
test.cc:13:5: error: invalid type argument of unary '*' (have 'int')

It's complaining that I'm trying to de-reference a primitive type from my first call to foo(), but that's exactly why I'm using the if-statement: to check if it's primitive or not. How would I go about implementing what I'm trying to do?

Answer 1

What you need to do, is write 2 versions of your templated function.

template<typename T>
void foo(T someVar) {
    cout << "Assume it's primitive! \n" << someVar << endl;
}

template<typename T>
void foo(T* pVar) {
    cout << "This is a pointer! \n" << *pVar << endl;
}

The compiler will choose the pointer version if it works, because it's more specific. If the type is not a (raw) pointer, it will default to the first version.

If you need smart pointers to be dereferenced, you can further overload your function definition.

Eg.

template<typename T>
void foo(std::shared_ptr<T> pVar) {
    cout << "This is a shared pointer! \n" << *pVar << endl;
}

Answer 2

You need an additional layer of indirection.

#include <iostream>

template < typename T >
struct print_helper
{
  static void
  print(std::ostream& os, const T& value)
  {
    os << "The value is " << value << "\n";
  }
};

template < typename T >
struct print_helper< T * >
{
  static void
  print(std::ostream& os, const T *const pointer)
  {
    os << "The pointer points to " << *pointer << "\n";
  }
};

template < typename T >
void
foo(T whatever)
{
  print_helper<T>::print(std::cout, whatever);
}


int
main()
{
  const auto a = 42;
  foo(a);
  foo(&a);
}

Output:

The value is 42
The pointer points to 42

Answer 3

A solution I'm partial to for just printing nicely is to write a function to do the dereferencing.

template<typename T> T &deref(T &elem) { return elem; }
template<typename T> T &deref(T *elem) { return *elem; }

Then you can simply use deref(value) anywhere you don't know whether or not value will be a pointer, as long as you don't care which it is.

template<typename T>
void print(T t) {
    std::cout << deref(t) << '\n';
}

Answer 4

Write the function twice:

struct Foo
{
    template<typename T>
    static void foo(T val) {
        cout << "var: " << val << endl;
    }

    template<typename T>
    static void foo(T* val) {
        cout << "ptr: " << *val << endl;
    }
};

To call:

int x;
int *y;
Foo::foo(x);
Foo::foo(y);