Member Avatar for knowill

very dificult oop, exception, inheritance task pleas. sorry, i'm hope you understand me.

  • 4 Contributors
  • 3 Replies
  • 255 Views
  • 1 Day Discussion Span
  • Latest Post Latest Post by raptr_dflo

Dani AI

Generated

A concise, practical guide that complements the earlier remarks from and cuts through the noise from and .

Design essentials

  • Model real relationships: use inheritance for true “is‑a” relationships; otherwise prefer composition.
  • Make base classes polymorphic only when runtime substitution is needed: mark the interface methods virtual and always provide a virtual destructor to avoid undefined behavior when deleting through a base pointer.

Concrete patterns (minimal examples)

class Base {
public:
    virtual ~Base() = default;
    virtual void doWork() = 0;
};

class Derived : public Base {
public:
    void doWork() override { /* implementation */ }
};

std::unique_ptr<Base> p = std::make_unique<Derived>();
p->doWork(); // polymorphic dispatch
struct MyError : std::runtime_error {
    MyError(const std::string& s) : std::runtime_error(s) {}
};

try {
    throw MyError("operation failed");
} catch (const std::exception& e) {
    // handle or log e.what()
}

Common pitfalls and quick fixes

  • Object slicing: storing derived objects by value in base-typed containers loses derived parts; store pointers/smart pointers instead.
  • Missing virtual destructor: leads to resource leaks or UB when deleting polymorphic objects via base pointers.
  • Exceptions: throw objects derived from std::exception, throw by value, catch by const&. Use RAII (smart pointers, lock guards) so resources aren’t leaked when exceptions propagate.
  • Don’t use exceptions for normal control flow; design for clear exception-safety (basic/strong/no-throw where appropriate).

Summary
This gives a minimal, modern set of patterns to make inheritance and exceptions behave predictably. The practical next step is to apply these patterns to a small class pair and observe object lifetime and exception propagation.

Recommended Answers

All 3 Replies

Member Avatar for Greywolf333

very dificult oop, exception, inheritance task pleas. sorry, i'm hope you understand me.

very large kittens, notwithstanding, inherit some peas. i'm hope you understand me.

commented: Lol +5
Member Avatar for Cross213

Funny stuff

Member Avatar for raptr_dflo

I'll take a stab at understanding you:
You find the fundamental object-oriented concepts difficult to understand, particularly inheritance (how a derived class automatically inherits members and methods from its parent class, and only new or changed functionality needs to be specified) and exceptions (a way of propagating error conditions back to the first caller in the chain with code that "catches" that exception, outside the normal function call stack). Am I close?

As far as gaining a better understanding of these concepts, if you can understand what I wrote above, then the next step is to clearly formulate a question regarding more specifically exactly what part of the concepts continue to cause you confusion.

All smart-assery aside, we really are here to help, but we're not going to teach you a course in "essential object-oriented concepts" for free.

Be a part of the DaniWeb community

We're a friendly, industry-focused community of developers, IT pros, digital marketers, and technology enthusiasts meeting, networking, learning, and sharing knowledge.