C++14 Class Function Error: "Object has no attribute 'value'" - c++

Question

EDIT: Total Overhaul
I am making a programming language (similar to Python), and at least for now, I am trying to compile it to C++. I'm having an error where C++ is saying that there is no member "value" in the class "Object". This is a compilation error. I understand why C++ is doing this, as it has to know the type of value at compile-time, and so I am asking for alternatives.
The only things it will be given are instances subclasses of Object, in which the member "value" will be defined, this is a compile error.
I can't declare the member "value" inside the Object class, because its type depends on which subclass it's in. This also has to work with floats and strings, so defining the function with an Integer instance instead of an Object instance won't work.
Here is some code with an example of how these objects will be used:
auto user_i = std::make_unique<Integer>(2);
std::cout << (*user_i).equals(*std::make_unique<Float>(2.0).get()) << std::endl;
Here are the important class definitions:
class Object {
public:
bool equals(Object& other) {
throw "Not implemented!";
}
};
class Integer: public Object {
public:
int value;
Integer(int val) {
value = val;
}
bool equals(Object& other) {
return value == other.value;
}
};
class Float: public Object {
public:
double value;
Float(double val) {
value = val;
}
bool equals(Object& other) {
return value == other.value;
}
};
class String: public Object {
public:
string value;
String(string val) {
value = val;
}
bool equals(Object& other) {
return value.compare(other.value) == 0;
}
};
It should not be the case that 2 == "2", but it should be the case that 2 == 2.0 == 2.000 etc.
There is then the added complication of methods like add (by this I mean returning a value, still not modifying the object). The equals method suggested by #Michael Karcher would work fine, but for example 2+3 should return 5, not 5.00000.
For even more trouble, User-Defined Objects (Classs in my language) should be able to override methods like add.

Answer 1

Your example has a couple of issues besides you main issues. I start with the minor issues to get them out of the way.
You need declare equals as virtual in the base class. Opposed to Java, dynamic dispatch is not the default in C++, but must be requested per method using the virtual attribute like this:
class Object {
public:
virtual bool equals(Object other) {
throw "Not implemented";
}
}
You are passing the object you compare to by value. Opposed to Java, in C++ even class types can be passed by value. This means that the function equals gets a copy of an Object to compare to - and just that. The parts of the object you want to compare to, including the value member, do not get copied into the argument passed to equals. You should pass the parameter by reference. As your equals function does not need to modify the object you compare to, a reference without write permission (commonly called a const reference due to the syntax) is enough:
class Object {
public:
virtual bool equals(const Object& other) {
throw "Not implemented";
}
}
If you are writing a base class that just provides a function signature which needs to be overridden in every derived class, you don't make it throw something, but you instead make it abstract by declaring it as a pure virtual function, using the =0 syntax. This prevents you from accidentally creating Object instances that can not be compared. This would have caught the missing pass-by-reference:
class Object {
public:
virtual bool equals(const Object& other) = 0;
}
Now, let's address your question:
This approach works in dynamically typed languages like JavaScript or Python, but it does not work in C++. During compilation, the compiler has to know where it finds the member value in the object other and its type. If you just pass in any Object, the compiler has no way of knowing it. And even you don't know: The type might be int or float. So neither you nor the compiler know whether there is a float value or an int value in the object you pass for comparison. If Integer objects should be comparable to both Integer and Float objects, you either need to comparison methods or you need a way to get a generic value of a common type. In this case, on machines with 32-Bit integers, every integer value is exactly representable in a double variable. You could add a second function to the Object class called as_double like this:
class Object {
public:
virtual bool equals(const Object &other) const = 0;
virtual double as_double() const = 0;
}
I also marked the methods const, which means you may call them on objects or using references you may not write to. Now you can implement Integer and Float like this:
class Integer: public Object {
public:
int value;
Integer(int val) {
value = val;
}
bool equals(const Object & other) const {
return value == other.as_double();
}
double as_double() const {
return value;
}
};
class Float: public Object {
public:
double value;
Float(double val) {
value = val;
}
bool equals(const Object & other) const {
return value == other.as_double();
}
double as_double() const {
return value;
}
};
And, if you look at the equals method, its now nearly the same for both types: You extract the value of argument as double, and compare it to the local value (in the case of Integer, the local value gets implicitly converted to double, too. So you could also use a generic comparison implementation that calls to_double on both objects, and you don't have to bother implementing equals in each subclass:
class Object {
public:
bool equals(const Object& other) const {
return as_double() == other.as_double();
}
virtual double as_double() const = 0;
}
Note, this only works because double actually is able to represent all values - even those stored in Integers. If your actual use-case does not have such a common type you can convert to, you need a more complicated solution.

Answer 2

Note that:
C++ is not a dynamically typed language, but a statically typed language. A variable's type is determined at compile time, and not runtime.
To have dynamic nature with the type, you need to have a polymorphic class - i.e. class having virtual functions. Through one or more virtual functions, you achieve the dynamic nature of the (class) type. The derived type (class) would (re)implement the necessary virtual functions
If you want to have types that seem dynamic but are static at compile time; then you can use templates. For example, an Add function can be:
template<typename Type>
Type Add(Type a, Type b)
{
return a+b;
}
And call them with any type:
Add(1,2); // int
Add(4.5, 5.0); // double
In the function, if you want to know the type, you can use certain helper functions like is_same:
Type Add(Type a, Type b)
{
if(std::is_same<Type, int>::value)
{
// Do whatever when 'int' is passed
}
...
}
The same approach can be used in class templates also. You may have (partial) template class specialization. vector with type bool is one example.
std::distance and std::advance are another examples which rely on the type of the container (in a simlpe sense) and are implemented differently (random access or sequence access).

Answer 3

The equal functions uses Object as the parameters type. Calling other.value does not work as you already pointed out Object does not have a parameter value. From the compiler point of view it will never get anything with a parameter value.
I suggest you rewrite the function definitions of equals to bool equals(Integer& other) and bool equals(Float& other).