Why does my class polymorphism fail (C++) - c++

Question

I want to return a struct which uses a number and one object deriving from one of 3 subclasses that tell the method where to add the number. My thought process is that using runtime polymorphism, I can overload the method and have the sum of different sub classes in 3 variables. However this doesn't seem to happen because the object doesn't get casted down to it's child class. Bear in mind, that the program doesn't know beforehand which subclass will be the struct, so manual casting is not possible.
The class with the subclasses (s.h):
#pragma once
class Sugar{};
class Nincs : public Sugar
{
private:
static Nincs* ins;
Nincs(){};
public:
static Nincs* instance();
};
class Alfa : public Sugar
{
private:
static Alfa* ins;
Alfa(){};
public:
static Alfa* instance();
};
class Delta : public Sugar
{
private:
static Delta* ins;
Delta(){};
public:
static Delta* instance();
};
The class with the subclasses (s.cpp):
#include "s.h"
Nincs* Nincs::ins = nullptr;
Alfa* Alfa::ins = nullptr;
Delta* Delta::ins = nullptr;
Nincs* Nincs::instance()
{
if (ins == nullptr)
{
ins = new Nincs();
}
return ins;
};
Alfa* Alfa::instance()
{
if (ins == nullptr)
{
ins = new Alfa();
}
return ins;
}
Delta* Delta::instance()
{
if (ins == nullptr)
{
ins = new Delta();
}
return ins;
}
The classes that return the struct (this is only n.h for now, I plan to separate it into .h and .cpp once this issue is resolved):
#pragma once
#include "s.h"
struct Sugarzas
{
Sugar* fajta;
int mennyiseg;
};
class Noveny
{
protected:
std::string nev;
int tapanyag;
bool el_e;
public:
Noveny(std::string v1, int v2, bool v3): nev(v1), tapanyag(v2), el_e(v3){}
virtual Sugarzas ker(){};
};
class Puffancs : public Noveny
{
public:
Puffancs(std::string v1, int v2, bool v3): Noveny(v1,v2,v3){};
Sugarzas ker() override
{
Sugarzas s;
s.fajta = Alfa::instance();
s.mennyiseg = 10;
return s;
}
};
class Deltafa : public Noveny
{
public:
Deltafa(std::string v1, int v2, bool v3): Noveny(v1,v2,v3){};
Sugarzas ker() override
{
Sugarzas s;
s.fajta = Delta::instance();
if (tapanyag < 5)
{
s.mennyiseg = 4;
}
else if (tapanyag >=5 && tapanyag <=10)
{
s.mennyiseg = 1;
}
else
{
s.mennyiseg = 0;
}
return s;
}
};
class Parabokor : public Noveny
{
public:
Parabokor(std::string v1, int v2, bool v3): Noveny(v1,v2,v3){};
Sugarzas ker() override{}
};
main file with the functions:
#include <iostream>
#include "s.h"
#include "n.h"
using namespace std;
int sumNincs, sumAlfa, sumDelta;
void addTo(Nincs* s, int x)
{
sumNincs += x;
}
void addTo(Alfa* s, int x)
{
sumAlfa += x;
}
void addTo(Delta* s, int x)
{
sumDelta += x;
}
int main()
{
Puffancs* n = new Puffancs("bob",5,true);
sumNincs = 0;
sumAlfa = 0;
sumDelta = 0;
Sugarzas s = n->ker();
addTo(s.fajta,s.mennyiseg); //s.fajta comes out as Sugar* and does not get casted to the subclasses
return 0;
}

Answer 1

It looks like there's some confusion between function overloading and function overriding. Virtual functions can be overridden, where a member function defined in a base class can be overridden by a member function with the same signature* in a derived class, and then calls to the base class method will be dispatched based on the actual runtime most derived class of the object the methods are being called on.
*Except possibly having a covariant return type.
However, your addTo functions are not a case of overriding. They are a case of overloading, where you have functions with the same name but different signatures. Overload resolution must be resolved at compile time. The static type of s.fajta is Sugar*, even though the actual pointed-to object is an Alfa.
You'd need your Sugar class to have virtual methods if you want to be able to have behavior that depends on the concrete type of *s.fajta. Since I'm not clear on what exactly is supposed to be happening here, I'm not sure how to restructure your program to use this behavior.