Access entire base class from derived class C++

user_15215724 0
Viewed 202

I understand that you can access members of the base class from a derived class, however, I have a function that requires a pointer to my base class as a whole. For example:

#include <iostream>
 
using namespace std;

function foo(Shape &s){
//does something
}

// Base class
class Shape {
   public:
      Shape(int w = 100, int h = 100){
         width = w;
         height = h;
      }
      void setWidth(int w) {
         width = w;
      }
      void setHeight(int h) {
         height = h;
      }
      
   protected:
      int width;
      int height;
};

// Derived class
class Rectangle: public Shape {
   public:
      Rectangle(){
        Shape();
      }
      int getArea() { 
         return (width * height); 
      }
};

int main(void) {
   Rectangle Rect;
   foo(// Pointer Reference to Rect.Shape here);

   return 0;
}

Is there any way to get a pointer to this base class from the derived class?

base-class derived-class pointers c++
1 Answers

Here's a working version of your code. I made some changes to it and added comments to explain the changes. Your program requires polymorphism to behave as expected, otherwise you'll 'slice' your derived object and just have a Base object.

#include <iostream>
#include <string>

// Base class
// Your base should only have things that would be common to all derived classes
// Consider what the width and height of a Circle would be
//
// You may not have gotten to virtual functions and polymorphism yet. This is
// how you would set up an interface for your Derived classes. I am requiring
// any derived class to implement getArea() and identify() if it wants to be a
// 'concrete' class. Otherwise it will be abstract, which means you can't
// declare objects of that type. It is not possible to declare a Shape object
// because of the pure virtual functions
class Shape {
 public:
  virtual ~Shape() = default;          // A virtual destructor is required
  virtual double getArea() const = 0;  // Pure virtual function
  virtual std::string identify() const = 0;
};

// Derived class
class Rectangle : public Shape {
 public:
  // The base class should be initialized in the constructor's
  // initialization section. What you did was declare a temporary Shape that
  // went away when the function ended.
  // All class data should be set in the initialization section
  Rectangle(int w, int h) : Shape(), width(w), height(h) {}
  double getArea() const override { return (width * height); }

  std::string identify() const override { return "Rectangle"; }

 private:
  int width = 0;
  int height = 0;
};

// A new derived class that should work (a circle **is-a** shape), but doesn't
// with your setup. Circles don't have width and height
class Circle : public Shape {
 public:
  Circle(int r) : Shape(), radius(r) {}
  double getArea() const override { return 2 * 3.14 * radius * radius; }
  std::string identify() const override { return "Circle"; }

 private:
  int radius = 0;
};

// Subjective, I moved the function below the class definitions and added a body
void foo(Shape &s) {
  std::cout << "A " << s.identify() << " with area " << s.getArea() << ".\n";
}

int main(void) {
  Rectangle rect(5, 3);
  foo(rect);

  Circle circ(4);
  foo(circ);

  return 0;
}

Output:

A Rectangle with area 15
A Circle with area 100.48

If I remove all the virtual stuff, a lot of things stop working. I now have to provide implementations for the Shape functions. That logically doesn't make much sense. And while I can pass my derived objects to foo(), they get sliced, and the filler Shape data gets printed instead.

user_61195820
Related