πηγαίοι κώδικες του αρχείου PDF

//-----------------------------------------------------------------------------------
//--- file: 08-Point2D.h
#pragma once

#include <iostream>

class Point2D {
  private:
    double x;
    double y;
  public:
    Point2D();
    Point2D(const double& x, const double& y);
    ~Point2D();
    double& getx();
    double& gety();
    void setx(const double& x);
    void sety(const double& y);
    friend std::ostream& operator<< (std::ostream& o, const Point2D& p);
};
//-----------------------------------------------------------------------------------
//--- file: 08-Circle.h
#pragma once

#include "08-Point2D.h"

class Circle {
  private:
    double R;
    Point2D C;
  public:
    Circle();
    Circle(const double&  R, const Point2D& C);
    Circle(const Point2D& C, const double&  R);
    Circle(const double& R, const double& x, const double& y);
    ~Circle();
    double& getR();
    Point2D& getC();
    void setR(const double&  R);
    void setC(const Point2D& C);
    friend std::ostream& operator<< (std::ostream& o, const Circle& p);
};
//-----------------------------------------------------------------------------------
//--- file: 08-Point2D.cpp
#include "08-Point2D.h"

Point2D::Point2D() : x(0), y(0) {}
Point2D::Point2D(const double& x, const double& y) : x(x), y(y) {}
Point2D::~Point2D() {}
double& Point2D::getx() {
  return x;
}
double& Point2D::gety() {
  return y;
}
void Point2D::setx(const double& x) {
  this->x = x;
}
void Point2D::sety(const double& y) {
  this->y = y;
}
std::ostream& operator<<(std::ostream& o, const Point2D& p) {
  o << "(" << p.x << ", " << p.y << ")";
  return o;
}
//-----------------------------------------------------------------------------------
//--- file: 08-Circle.cpp
#include "08-Circle.h"

Circle::Circle() : R(0), C(Point2D()) {}
Circle::Circle(const double& R, const Point2D& C) : R(R), C(C) {}
Circle::Circle(const Point2D& C, const double& R) : R(R), C(C) {}
Circle::Circle(const double& R, const double& x, const double& y)
              : R(R), C(Point2D(x, y)) {}
Circle::~Circle() {}
double& Circle::getR() {
  return R;
}
Point2D& Circle::getC() {
  return C;
}
void Circle::setR(const double& R) {
  this->R = R;
}
void Circle::setC(const Point2D& C) {
  this->C = C;
}
std::ostream& operator<<(std::ostream& o, const Circle& c) {
  o << "Κύκλος με ακτίνα " << c.R << " και κέντρο " << c.C;
  return o;
}
//-----------------------------------------------------------------------------------
#include <iostream>   //--- file: 08-testCircle.cpp
#include "08-Point2D.h"
#include "08-Circle.h"

int main() {
  Point2D p1;           // Σημείο με χρήση του default constructor
  Point2D p2(3.0, 4.0); // Σημείο με χρήση του constructor με παραμέτρους
  std::cout << "Σημείο p1: " << p1 << std::endl;   // Εμφάνιση των σημείων
  std::cout << "Σημείο p2: " << p2 << std::endl;
  
  p1.setx(1.5);    p1.sety(2.5);
  std::cout << "Νέες συντεταγμένες του p1: " << p1 << std::endl;

Circle c1;                 // Κύκλος με χρήση του default constructor
  Circle c2(5.0, p2);        // Κύκλος με ακτίνα 5 και κέντρο p2
  Circle c3(10.0, 0.0, 0.0); // Κύκλος με ακτίνα 10 και κέντρο (0, 0)

std::cout << "Κύκλος c1: " << c1 << std::endl;   // Εμφάνιση των κύκλων
  std::cout << "Κύκλος c2: " << c2 << std::endl;
  std::cout << "Κύκλος c3: " << c3 << std::endl;

// Ρυθμίσεις για c1
  c1.setR(7.5);
  c1.setC(Point2D(2.0, 3.0));
  std::cout << "Νέες ιδιότητες του c1: " << c1 << std::endl;

// Πρόσβαση και αλλαγή δεδομένων μέσω get
  double& radius = c2.getR();
  radius = 8.0; // Αλλαγή ακτίνας μέσω αναφοράς
  std::cout << "Αλλαγμένη ακτίνα του c2: " << c2.getR() << std::endl;
}
//-----------------------------------------------------------------------------------
#include <iostream>
using namespace std;

class Base {
  public:
    void display() {
      cout << "Called the display() method from the Base class." << endl;
    }
};

class Derived : public Base {
  public:
    void show() {
      cout << "Called the show() method from the Derived class." << endl;
    }
};

int main() {
  Derived obj;
  obj.display(); // Κληρονομημένη μέθοδος από τη βασική κλάση
  obj.show();    // Μέθοδος της παράγωγης κλάσης
}
//-----------------------------------------------------------------------------------
#include <iostream>
using namespace std;

class Base {
  public:
    void print(int x) {
      cout << "Base class: x = " << x << endl;
    }
};

class Derived : public Base {
  public:
    void print(int x, int y) {
      cout << "Derived class: x = " << x << ", y = " << y << endl;
    }
    void print(double z) {
      cout << "Derived class: z = " << z << endl;
    }
};

int main() {
  Derived obj;

// Χρήση υπερφορτωμένων μεθόδων της Derived class
  obj.print(10, 20);   // Κλήση με δύο ακέραιους
  obj.print(3.14);     // Κλήση με έναν δεκαδικό

obj.print(5);           // Ποια μέθοδος θα κληθεί;...
  obj.Base::print(5);     // Άμεση κλήση της μεθόδου της Base class
  obj.Derived::print(5);  // Άμεση κλήση της μεθόδου της Derived class
}
//-----------------------------------------------------------------------------------
#include <iostream>
#include <cmath>
using namespace std;

class Shape {
  public:
    virtual double area() const = 0; // Καθαρά εικονική μέθοδος
};

class Circle : public Shape {
  private:
    double radius;
  public:
    Circle(double r) : radius(r) {}
    double area() const override {
      return M_PI * radius * radius; // A = πr²
    }
};

class Square : public Shape {
  private:
    double side;
  public:
    Square(double s) : side(s) {}
    double area() const override {
      return side * side; // A = α²
    }
};

int main() {
  Shape* shapes[4]; // Πίνακας τεσσάρων δεικτών προς αντικείμενα της κλάσης Shape
  shapes[0] = new Circle(5.0); // Κύκλος με ακτίνα 5
  shapes[1] = new Square(4.0); // Τετράγωνο με πλευρά 4
  shapes[2] = new Circle(7.2); // Κύκλος με ακτίνα 7.2
  shapes[3] = new Square(2.3); // Τετράγωνο με πλευρά 2.3

for (int i = 0; i < 4; ++i) {
    cout << "Εμβαδόν: " << shapes[i]->area() << endl;
  }

// Καθαρισμός μνήμης
  delete shapes[0];
  delete shapes[1];
  delete shapes[2];
  delete shapes[3];
}
//-----------------------------------------------------------------------------------
class Shape {
public:
    virtual void draw() const = 0; // Pure virtual method
    virtual ~Shape() {} // Εικονικός destructor
};
//-----------------------------------------------------------------------------------
class Circle : public Shape {
private:
    double radius;
public:
    Circle(double r) : radius(r) {}
    void draw() const override {
        cout << "Drawing a circle with radius " << radius << endl;
    }
};
//-----------------------------------------------------------------------------------