Accessing object data/method members with templates - c++

Question

Suppose I implement my own Linked List and its nodes can hold elements of type "Car".
Within this implementation I have a method, PrintList(), which has a loop and calls the toString method for each node.
What my class looks like for reference:
template<class T>
class ArrayList {
private:
class Node {
private:
// Node accessors
T* element;
public:
// ctor's
//Accessors etc
void GetElement();
string toString();
};
//members
int size;
// etc
public:
void PrintList();
};
The node's toString() looks something like this:
string myNode::toString() {
// Returns a Car pointer.
// Still in myList implementation
// For a generic version I'ld want 'getEleemnt' or something.
return this->GetCar()->toString();
}
Car* Mylist::Node::GetCar() {
//Returns a car* ptr
return this->myCar;
//car has an implementation of toString() which is soon invoked.
}
//Inside my Car class written in some other cpp file, has no relationship
//with MyList.
string Car()::toString() {
//Car type is a set of enums defined in a header.
//Car has a EnumeratedType member field.
switch ( this->getEnumeratedType ) {
case 0:
return "I'm a veyron"
// etc
}
}
Suppose I now implement my own Linked List template. (Because as a student I find the exercise interesting and a good opportunity to practice my C++). The above toPrint() shenanigans don't work.
template <class T>
string MyList<T>::myNode::toString() {
// Returns a T* pointer.
// now in generic <T> myList implementation
//
return this->GetElement()->toString(); // this does not compile....
}
template <class T>
T* Mylist<T>::Node::GetElement() {
//Returns a element* ptr?
return this->myElement;
// This compiles iirc.
}
There does not seem to be a way to call a method on a unknown class template. Car has no relationship with myList, I could be interested in storing ANY object that isn't related to Car, suppose I wanted to Store flowers, even if they both have toString implementations, the compiler doesn't let me call them.
A possible suggestion was to create an IPrintable interface that any object I'ld intend to have be used by the generic list inherit from, but I don't know if this really solves my issue.
To summarize, I am returning a pointer, type "T", that could be Car, or could be Flowers, and I want to know if there's some way of throwing toString() darts blindly and get them to invoke their implementations.

Answer 1

It seems like you have implemented your own list class, so I can't comment on that. But let me explain it by using just regular stl containers. When you have a container of a specific type:
std::vector<Car> cars;
You can put in just that type:
cars.push_back(Car());
cars.push_back(User()); // ERROR
If you use polymorphism you can store different kinds of objects (that inherit from the same base-class) inside a container when using pointers:
#include <iostream>
#include <vector>
#include <memory>
class Car {
public:
virtual ~Car() {}
virtual std::string toString() const {
return "I'm a car";
}
};
class RaceCar : public Car {
public:
virtual std::string toString() const {
return "I'm a race car";
}
void raceCarSpecificMethod() const { }
};
int main() {
typedef std::shared_ptr<Car> CarPtr;
std::vector<CarPtr> cars;
cars.emplace_back(std::make_shared<Car>());
cars.emplace_back(std::make_shared<RaceCar>());
for (const auto &car : cars) {
std::cout << car->toString() << std::endl;
}
return 0;
}
However, you can NOT call methods like "raceCarSpecificMethod()" this way. If you want to call that method you would have to change the for loop to this:
for (auto &car : cars) {
std::cout << car->toString() << std::endl;
std::shared_ptr<RaceCar> race_car = std::dynamic_pointer_cast<RaceCar>(car);
if (race_car) {
race_car->raceCarSpecificMethod();
}
}
The dynamic_pointer_cast casts the Car pointer to a RaceCar pointer, making it possible for you to use the raceCarSpecificMethod. You MUST check if the returned pointer is a nullptr. If the casted pointer is NOT a RaceCar pointer a nullptr will be returned. If the above example I used shared_ptrs, when using regular pointers you should use:
RaceCar *race_car = dynamic_cast<RaceCar*>(car); // assuming that car is a Car*
I'm not sure why you are writing your own list class but in general I'd advice you to stick to std::vector.