Is it possible to transfer type to C++ method or determine type in the method?

Question

I am trying to implement a list of data of any type by myself, and I want to print this list based on the data type. At this point, I have tested integers and characters. To print a list of these types, there are two methods print_int and print_char, depending on the data type being displayed. My question is, is it possible to define only one method print that will print depending on the data type of my list without creating a class template (unlike List<type> ...)? I mean without this class definition:

template <class T>
class List{
  T *data;
  List *next;
  ...

-------------------------- UPDATE--------------------------

Finally, I found a solution that gives me the ability to dynamically check the type in C++ (using dynamic_cast, see the accepted answer). Unfortunately, many people mistakenly believe that C++ is severely limited. Which demonstrates my question, to which many, not knowing the answer, put minuses.

Answer 1

If you want to store any type in a list without losing type information, you might try a polymorphic approach, too:

class NodeBase
{
public:
    virtual ~NodeBase();
    virtual void print() = 0;

    template <typename T>
    void append(T t);

protected:
    NodeBase* next;

    void appendNode(NodeBase* node);
};

template<typename T>
class Node : public NodeBase
{
public:
    void print() override { ... }

private:
    T data;
};

template <typename T>
void NodeBase::append(T t) // as being template, needs to remain in header!
{
    appendNode(new Node<T>(t));
}

Finally the print implementation might use different overloads of another function to actually print the data value.

Side note: I'd prefer to rename the current List class to Node and make it an inner class of a newly created List class which would manage the nodes internally. The current list implementation can easily result in memory leaks if you move the only pointer to head to a successor of.

Answer 2

Unfortunately, many people mistakenly believe that C++ is severely limited. Which demonstrates my question, to which many, not knowing the answer, put minuses. Luckily, I found a solution/answer that gives me the ability to dynamically check the type in C++ using dynamic_cast. So using if (dynamic_cast<TypeToCheck*>(data)) you can check the data type (is it equal to type TypeToCheck?). Unfortunately, this only works for class types.

I think it's helpful, so here's the implementation:

The list class (list.h):

#pragma once
#include <iostream>

using namespace std;


class Base {
public:
    virtual ~Base() {};
};


class Char : public Base {
    char value;
public:
    Char(char value) : value(value) {};

    friend ostream& operator << (ostream& stream, const Char* self) {
        return stream << "'" << self->value << "'";
    };
};


class Int : public Base {
    int value;
public:
    Int(int value) : value(value) {};

    friend ostream& operator << (ostream& stream, const Int* self) {
        return stream << self->value;
    };
};


class Float : public Base {
    float value;
public:
    Float(float value) : value(value) {};

    friend ostream& operator << (ostream& stream, const Float* self) {
        return stream << self->value;
    };
};


class List
{
    Base* data = nullptr;
    List* next = nullptr;
public:
    List() {};
    List(Base* data):data(data) {};

    void set_next(List* next) {this->next = next;};

    void append(Base* data) {
        List *last_element = this;
        while(last_element->next)
            last_element = last_element->next;

        last_element->set_next(new List(data));
    };

    void print_element(){
        if (dynamic_cast<Char*>(data))
            std::cout << (Char*)data << "(Char)";
        else if (dynamic_cast<Int*>(data))
            std::cout << (Int*)data << "(Int)";
        else if (dynamic_cast<Float*>(data))
            std::cout << (Float*)data << "(Float)";
    }
    void print() {
        bool is_first = true;
        
        cout << endl << "list " << static_cast<void*>(this) << " [";

        List* element = this;
        while(element) {
            if (is_first)
                is_first = !is_first;
            else
                cout << ", ";
            element->print_element();
            element = element->next;
        }
        cout << "]" << endl;
    };
};

Testing file (main.cpp):

#include "list.h"

int main()
{
    List myList(new Int(10));
    myList.append(new Float(1.203f));
    myList.append(new Int(12));
    myList.append(new Char('f'));
    
    myList.print();

    return 0;
}

Result is:

list 000000000014F6D8 [10(Int), 1.203(Float), 12(Int), 'f'(Char)]

Answer 3

That is a very simple list!

template <class T>
class List{
   T*    data;
   List* next;

   void print() {
       std::cout << "[ ";
       print(this, "");
       std::cout << " ]\n";
   }
   void print(List* node, std::string const& sep) {
       if (node == nullptr) {
           return;
       }
       std::cout << sep << node->data;
       print(node->next, ", ");
   }
}

That should work for any type that supports normal stream output. Now this should get you going but I would change how you implement list a lot. Think of a list as the owner of a set of nodes. The nodes hold the data but are not the list.

Answer 4

Let's try a different approach: pointers to print functions.
Let's create a synonym for a print function:

typedef (void) (*(Ptr_Print_Function)(std::ostream& output, void * node_data));

Since each node can be of a different type, something will have to initialize the print function correctly.

struct Node
{
  void * p_data;
  Node * prev_node;
  Node * next_node;
  Ptr_Print_Function p_printer;
};

Here are some addition forwarded declarations:

void Print_Integer_Node(std::ostream& output, void * p_data);
void Print_Char_Node(std::ostream& output, void * p_data);  

Here's a code fragment for printing the node to std::cout:

Node * p_node;
//... node search / initialize
(p_node->p_printer)(std::cout, p_node->p_data);

Edit 1: Data Inheritance
IMHO, a cleaner method is to use inheritance and a base (interface) class for the data.

struct List_Data_Interface
{
    virtual void print_data(std::ostream& output) = 0;
    void * p_data;
};

struct Node_Version_2
{
    List_Data_Interface * p_data;
    Node_Version_2 *      p_prev;
    Node_Version_2 *      p_next;
};

In the above model, we are assuming that the data for every node has a print method and a pointer to some data.

A sample integer data:

struct Integer_Data : public List_Data_Interface
{
  void print_data(std::ostream& output)
  {
      int * p_int_data = (int *) p_data;
      output << *p_int_data;
  }
};

Here's some code on how to print a node using the above Node_Version_2:

//...
Node_Version_2 p_node;
//... initialize or find the node.
p_node->print_data(std::cout);

Through polymorphism the correct print function will be chosen.