Lampa i dwie żarówki (po obiektowemu bez dziedziczenia)

Question

Cześć :)

Wykouję zadanie , które z tego co zrozumiałem ma przedstawiać klasę "Lampa" z posiadaniem jako składowe dwóch obiektów klasy "Zarowka" (wygląda na to, że bez dziedziczenia).

Oto treść zadania:

Żarówka. Ma prywatne pole moc typu int. Konstruktor umożliwia ustawienie wartości tego pola. W przypadku niepodania wartości w konstruktorze przyjmuje się domyślnie 100. Ma publiczną funkcję UstawMoc która ustawia to pole na przekazaną w argumencie wartość, oraz publiczną funkcję OdczytajMoc która zwraca wartość tego pola.
Lampa. Ma dwa prywatne pola typu Żarówka. Ma publiczną funkcję UstawMocLampy ustawiającą moc obu żarówek na zadaną wartość. Ma funkcję Wyświetl wyświetlającą moc żarówek na konsoli. Klasa zawiera funkcje wymagane do jej poprawnej pracy (konstruktor kopiujący, operator przypisania, destruktor)
Zaprezentować przykłady działania.

Adnotacje:
- wypisać błąd jeżeli moc żarówki byłaby większa niż 120
- opcjonalnie można zastąpić pola prywatne "Zarowek" kolekcją (tego drugiego jeszcze praktycznie nie używałem w praktyce)

Oto mój kod z interfejsu (plik elektryka.h):

#ifndef ELEKTRYKA_H_
#define ELEKTRYKA_H_

class Zarowka
{
  public:
    int m_power;
  public:
    Zarowka(int power = 100);
    void setPower(int user_argument);
    void readPower();
    ~Zarowka();
};

class Lampa
{
  private:
    Zarowka one, two;
  public:
  Lampa();
  Lampa(int powerForBulbs) : one(powerForBulbs){};
  void setPowerLamp(int user_argument);
  void readPowerLamp();
  ~Lampa();
};

#endif

I początek implementacji dla samej tylko zarowki:

#include <iostream>
#include "elektryka.h"

Zarowka::Zarowka(int power )
{
  m_power = power;
}

void Zarowka::setPower(int user_argument)
{
  m_power = user_argument;
}
void Zarowka::readPower()
{
  std::cout << "Power of the bulb: " << m_power << std::endl;
}

Tak więc parę pytań na start. Jak powinien wyglądać prototyp i implementacja dla konstruktora lampy, aby prawidłowo inicjalizować obydwa obiekty klasy "Zarowka"? Zastanawia mnie fragment o poprawnym rozpisaniu destruktora, ponieważ nie wygląda na to, aby było trzeba mu poświęcać większej uwagi (brak jakiejkolwiek alokacji pamięci itd.). Z góry dziękuję za wszelkie odpowiedzi.  :)

Answer 1

Przeczytaj jeszcze raz treść zadania.

Klasy mają mieć postać

class Zarowka
{
public:
    int m_power;
public:
    Zarowka(int power = 100);
    void UstawMoc(int power);
    int OdczytajMoc();
    ~Zarowka();
};
 
class Lampa
{
private:
    Zarowka one, two;
public:
    Lampa();
    Lampa(const Lampa& other);
    Lampa &operator=(const Lampa &other);
    void UstawMocLampy(int power);
    void Wyswietl();
    ~Lampa();
};

Aby zainicjalizować pola klasy przeanalizuj przykład

class Klasa {
private:
    int mA, mB, mC;
public:
    Klasa(int a, int b, int c) :
        mA(a),
        mB(b),
        mC(c)
    {
    }
}

Twoje destruktory mogą zostać puste.

Comments

Przepraszam za te nazwy po angielsku funkcji, to był pierwszy szkic i raczej pierwsze przemyślenia nad zadaniem, dlatego pojawiły się takie nazwy. 

Chyba skończyłem. Podaję niżej pełne rozwiązanie.

elektryka.h (interfejs)

#ifndef ELEKTRYKA_H_
#define ELEKTRYKA_H_

class Zarowka
{
  public:
    int m_power;
  public:
    Zarowka(int moc = 100);
    void UstawMocZarowki(int moc);
    int OdczytajMocZarowki();
    ~Zarowka() {};
};

class Lampa
{
  private:
    Zarowka one, two;
  public:
  Lampa() :
  one(),
  two() {};
  Lampa(int moc) :
    one(moc),
    two(moc) {};
  Lampa(const Lampa & innaLampa);
  Lampa & operator=(const Lampa & innaLampa);
  void UstawMocLampy(int power);
  void OdczytajMocLampy();
  ~Lampa() {};
};

#endif

elektryka.cpp (implementacja)

#include <iostream>
#include "elektryka.h"

Zarowka::Zarowka(int power )
{
  m_power = power;
}

void Zarowka::UstawMocZarowki(int power)
{
  m_power = power;
}
int Zarowka::OdczytajMocZarowki()
{
  return m_power;
}

Lampa::Lampa(const Lampa & innaLampa)
{
  one = innaLampa.one;
  two = innaLampa.two;
}
Lampa & Lampa::operator=(const Lampa & innaLampa)
{
  one = innaLampa.one;
  two = innaLampa.two;
  return *this;
}
void Lampa::UstawMocLampy(int power)
{
  if(power > 0 && power < 120 )
  {
    one.UstawMocZarowki(power);
    two.UstawMocZarowki(power);
  }
  else
  {
    std::cout << "Nie mozna bylo ustawic mocy zarowek ze wzglednu na to, ze nie moga miec mocy ponizej 0," << std::endl;
    std::cout << "jak i nie moga przekroczyc wartosci 120." << std::endl;
  }
}
void Lampa::OdczytajMocLampy()
{
  std::cout << "Moc pierwszej zarowki lampy: " << one.OdczytajMocZarowki() << std::endl;
  std::cout << "Moc drugiej zarowki lampy: " << two.OdczytajMocZarowki() << std::endl;
}

main.cpp (działanie)

#include <iostream>
#include "elektryka.h"

int main()
{
  Lampa pierwsza;
  std::cout << "Obiekt 'pierwsza' klasy Lampa" << std::endl;
  pierwsza.OdczytajMocLampy();
  pierwsza.UstawMocLampy(130);
  pierwsza.OdczytajMocLampy();
  pierwsza.UstawMocLampy(110);
  pierwsza.OdczytajMocLampy();


  Lampa druga(pierwsza);
  std::cout << "Druga Lampa (konstruktor kopiujacy z parametrem obiekt 'pierwsza' klasy Lampa ). " << std::endl;
  druga.OdczytajMocLampy();
  druga.UstawMocLampy(75);
  druga.OdczytajMocLampy();

  Lampa trzecia;
  std::cout << "Trzecia Lampa (operator przypisania z parametrem obiekt 'druga' klasy Lampa). " << std::endl;
  trzecia = druga;
  trzecia.OdczytajMocLampy();
  return 0;
}