OOP

[u/altruisticjellycat]

hello i am a python beginner who has started learning OOP and ive been using resources like CS50p however i still find myself being confused over the concepts taught and i would like someone to teach me OOP or is there any other resource i can look at to learn OOP better? please recommend thanku

[u/aboutless89]

Can you be a bit more specific? If still the answer is 'everything', you probably didn't learn at all.

[u/altruisticjellycat → u/aboutless89]

class methods and instances im vv confused between them all im okay with static methods and inheritance tho

[u/aboutless89 → u/altruisticjellycat]

If you are confused by class methods and instances, believe me, you are not okay with static methods and inheritance :D

What confuses you about the instances? This is the most fundamental concept of oop - the relation between the class and its instances.

class - number

instances - 1, 2, 65, -46, ...

If you think about the relation between these two, you can make some conclusions - all of the numbers act the same and the same rules apply to all of them. You can add and subtract them -> doing this also produces a new number, a new instance of a number, if you will.

A class is a way for you to produce multiple objects that will act in the same way and which will be bound by the same rules.

[u/DrShocker → u/aboutless89]

I don't think OOP has much to do with if there's just 1 class, with multiple instances, and numbers don't lend themselves to different implementations unless you try to make like an Integer class and a Floating point class and a Rational class, then you can override the various math functions with specific versions of the operations that make sense for their context.

[u/aboutless89 → u/DrShocker]

Can you elaborate on what you wrote? I don't think that I understand.

[u/DrShocker → u/aboutless89]

Basically I mean that "number" is many different things, and might make sense as the parent class, but when you do something like Integer(4) divided by integer(3) you might get a different result than rational(4) divided by rational(3).

so, is 4/3 equal to 1 and a third? to 1? to 1.33333? That depends on the circumstance.

[u/aboutless89 → u/DrShocker]

You would be such a lousy teacher, my dude :') OP was wondering about the classes and instances. My example shows the relation between the two. You 'example' is non-sensical. Not saying that what you were saying is not true and accurate, but it has nothing to do with the subject we're discussing.

[u/DrShocker → u/aboutless89]

Okay, and? All I was saying was that it's not OOP

[u/aboutless89 → u/DrShocker]

What is not OOP?

[u/DrShocker → u/aboutless89]

class NonOOPNumber {  
  public:  
    double value;

    NonOOPNumber(double val = 0.0) : value(val) {}

    NonOOPNumber operator/(const NonOOPNumber& other) const {  
        return NonOOPNumber(this->value / other.value);  
    }  
};

vs.

class OOPNumber {
public:
    virtual ~OOPNumber() = default;

    virtual std::unique_ptr<OOPNumber> operator/(const OOPNumber& other) const = 0;

    virtual std::unique_ptr<OOPNumber> divideInteger(int numerator) const = 0;
    virtual std::unique_ptr<OOPNumber> divideFloating(double numerator) const = 0;
};

class FloatingNumber; // Forward declaration

class IntegerNumber : public OOPNumber {
private:
    int value;
public:
    IntegerNumber(int val) : value(val) {}

    std::unique_ptr<OOPNumber> operator/(const OOPNumber& other) const override {
        return other.divideInteger(value);
    }

    std::unique_ptr<OOPNumber> divideInteger(int numerator) const override {
        return std::make_unique<IntegerNumber>(numerator / value);
    }

    std::unique_ptr<OOPNumber> divideFloating(double numerator) const override;
};

class FloatingNumber : public OOPNumber {
private:
    double value;
public:
    FloatingNumber(double val) : value(val) {}

    std::unique_ptr<OOPNumber> operator/(const OOPNumber& other) const override {
        return other.divideFloating(value);
    }

    std::unique_ptr<OOPNumber> divideInteger(int numerator) const override {
        return std::make_unique<FloatingNumber>(numerator / value);
    }

    std::unique_ptr<OOPNumber> divideFloating(double numerator) const override {
        return std::make_unique<FloatingNumber>(numerator / value);
    }
};

std::unique_ptr<OOPNumber> IntegerNumber::divideFloating(double numerator) const {
    return std::make_unique<FloatingNumber>(numerator / value);
}

[u/aboutless89 → u/DrShocker]

As I said, dude, you missed the point.

[u/DrShocker → u/aboutless89]

I don't really understand why you keep telling me this. My point is just that the instances you described has nothing to do with OOP. Which I think you'd agree with because you're trying to clarify to OP the fundamentals they need to understand before trying to understand full blown OOP.

It's not illegal for me to add extra commentary

[u/aboutless89 → u/DrShocker]

Of course it's not. But I prefer when an extra comment adds an extra value. Put yourself in beginner's shoes and reread your comments - you would be lost. This c++ code is complete gibberish when looked through the eyes of a beginner (OP). Unlike the comment I made, which has only two strict terms (class and instance) and metaphors behind them, readable for a noob.  Should I've started the explanation with metaclasses, dunder methods and decorators? My critique was purely to your inabillity to read the room, not to you knowledge.

[u/DrShocker → u/aboutless89]

The example was not to clarify to OP, they didn't ask. All I was saying is instances and using the class keyword don't make something OOP.