[C++] Konstruktor konwertujący.

[Pneumokok]

Witam!

Na wstępie chciałbym podziękować koledze Afishowi za pomoc przy ostatnim problemie -> klik. Teraz niestety zmuszony jestem Was prosić o pomoc przy kolejnym.
Otóż:
Chcąc przypomnieć sobie jak działa konstruktor konwertujący, postanowiłem napisać program zawierajacy dwie klasy - Szyba i Okno. Zamierzałem konwertować obiekt klasy Szyba na obiekt klasy Okno wychodząc z założenia, że szyba jest szczególnym przypadkiem okna które nie ma ram okiennych - niekoniecznie ma to sens, ale i sam program służyć ma tylko przypomnieniu jak konwersja się odbywa.
Oto kody:

plik main.cpp

Ukryta treść:    

Kod: Zaznacz cały

#include <cstdlib>

#include "Okno.h"
#include "Szyba.h"

using namespace std;

/*
 * 
 */
int main(int argc, char** argv) {
    Okno okno;
    //okno.pokazInfo();
    
    Okno okienko=okno;
   // okienko.pokazInfo();
    Szyba szyba;
  //  szyba.pokazInfo();
    
    Szyba szybka=szyba;
   // szybka.pokazInfo();
    return 0;
}

Plik Okno.h:

Ukryta treść:    

Kod: Zaznacz cały

#ifndef OKNO_H
#define	OKNO_H

//class Szyba;
class Okno {
public:
    Okno(int tSzerokoscSzyby=50, int tWysokoscSzyby=180, int szerokoscRamki=15, int wysokoscRamki=10);
    Okno(const Okno& orig);
    Okno(const Szyba szyba);
    virtual ~Okno();
    void pokazInfo();
private:
    const int szerokoscSzyby;
    const int wysokoscSzyby;
    int szerokoscRamki;
    int wysokoscRamki;
};

#endif	/* OKNO_H */

Plik Okno.cpp:

Ukryta treść:    

Kod: Zaznacz cały

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

class Szyba;
Okno::Okno(int tSzerokoscSzyby, int tWysokoscSzyby, int szerokoscRamki, int wysokoscRamki):
szerokoscSzyby(tSzerokoscSzyby), wysokoscSzyby(tWysokoscSzyby)
{
    this->szerokoscRamki=szerokoscRamki;
    this->wysokoscRamki=wysokoscRamki;
}

Okno::Okno(const Okno& orig):
szerokoscSzyby(orig.szerokoscSzyby), wysokoscSzyby(orig.wysokoscSzyby)
{
    this->szerokoscRamki=orig.szerokoscRamki;
    this->wysokoscRamki=orig.wysokoscRamki;
    std::cout<<"Zrobilem kopie okna!"<<std::endl;
}

Okno::Okno(const Szyba szyba):
szerokoscSzyby(szyba.getSzerokoscSzyby()), wysokoscSzyby(szyba.getWysokoscSzyby())
{
    this->szerokoscRamki=0;
    this->wysokoscRamki=0;
}

Okno::~Okno() {
    std::cout<<"Wybijam szybe! Ramka bezuzyteczna..."<<std::endl;
    szerokoscRamki=0;
    wysokoscRamki=0;
}

void Okno::pokazInfo(){
    std::cout<<"Nowe okno!"
            <<"Jego wymiary to: "<<std::endl
            <<"Szerokosc ramki okna: "<<szerokoscRamki<<std::endl
            <<"Wysokosc ramki okna: "<<wysokoscRamki<<std::endl
            <<"Szerokosc szyby okna: "<<szerokoscSzyby<<std::endl
            <<"Wysokosc szyby okna: "<<wysokoscSzyby<<std::endl
            <<std::endl;
}

Plik Szyba.h:

Ukryta treść:    

Kod: Zaznacz cały

#ifndef SZYBA_H
#define	SZYBA_H
class Okno;
class Szyba {
public:
    Szyba(int tSzerokoscSzyby=50, int tWysokoscSzyby=180);
    Szyba(const Szyba& orig);
    virtual ~Szyba();
    void pokazInfo();
    const int getWysokoscSzyby() const;
    const int getSzerokoscSzyby() const;
    friend Okno::Okno(Szyba);
private:
    const int szerokoscSzyby;
    const int wysokoscSzyby;

};

#endif	/* SZYBA_H */

Plik Szyba.cpp:

Ukryta treść:    

Kod: Zaznacz cały

#include<iostream>
#include "Szyba.h"
//class Okno;
Szyba::Szyba(int tSzerokoscSzyby, int tWysokoscSzyby):
szerokoscSzyby(tSzerokoscSzyby), wysokoscSzyby(tWysokoscSzyby)
{
}

Szyba::Szyba(const Szyba& orig):
szerokoscSzyby(orig.szerokoscSzyby), wysokoscSzyby(orig.wysokoscSzyby)
{
    std::cout<<"Zrobilem kopie szyby"<<std::endl;
}

Szyba::~Szyba() {
    std::cout<<"Rozbilbym szybe, ale nie wolno...:("<<std::endl;
}

void Szyba::pokazInfo(){
    std::cout<<"Jestem szyba! Wymiary:"<<std::endl
            <<"Szerokosc: "<<szerokoscSzyby<<std::endl
            <<"Wysokosc: "<<wysokoscSzyby<<std::endl
            <<std::endl;
}

const int Szyba::getWysokoscSzyby() const {
    return wysokoscSzyby;
}

const int Szyba::getSzerokoscSzyby() const {
    return szerokoscSzyby;
}

Idea jest następująca - tworzę konstruktor klasy Okno przyjmujacy jako argument obiekt klasy Szyba, dzięki temu że klasa Szyba jest zaprzyjaźniona z owym konstruktorem klasy Okno może on (a przynajmniej powinien móc, o ile program by działał) używać składowych prywatnych klasy Szyba jakby były publiczne.

Otrzymuję następujący błąd kompilacji:

Ukryta treść:    

Szyba.h:19:28: error: invalid use of incomplete type 'struct Okno'
Szyba.h:10:7: error: forward declaration of 'struct Okno'

Problem w tym, że nie bardzo wiem, jak sprawić by klasa Szyba wiedziała, że Okno jest nazwą klasy i na odwrót. Różne kombinacje z deklaracjami zapowiadajacymi (na górze każdego pliku, wspomina o nich Grębosz w Symfonii) lub ich brakiem (ujęcie w komentarz) nie powiodły się i dają podobne błędy. ,,Extern class" również nie pomaga.

Z góry dziękuję za pomoc przy rozwiązaniu problemu.
Pozdrawiam,
Pneumokok.

[Afish]

W pliku Okno.cpp załączaj oba nagłówki (Okno.h i Szyba.h). W pliku Okno.h daj

Kod: Zaznacz cały

#ifndef OKNO_H
#define   OKNO_H
class Szyba;

class Okno {
public:
    Okno(int tSzerokoscSzyby=50, int tWysokoscSzyby=180, int szerokoscRamki=15, int wysokoscRamki=10);
    Okno(const Okno& orig);
    Okno(const Szyba szyba);
    virtual ~Okno();
    void pokazInfo();
private:
    const int szerokoscSzyby;
    const int wysokoscSzyby;
    int szerokoscRamki;
    int wysokoscRamki;
};

#endif   /* OKNO_H */

W pliku Szyba.h daj

Kod: Zaznacz cały

#ifndef SZYBA_H
#define   SZYBA_H
#include "Okno.h"


class Szyba {
public:
    Szyba(int tSzerokoscSzyby=50, int tWysokoscSzyby=180);
    Szyba(const Szyba& orig);
    virtual ~Szyba();
    void pokazInfo();
    const int getWysokoscSzyby() const;
    const int getSzerokoscSzyby() const;
    friend Okno::Okno(Szyba);
private:
    const int szerokoscSzyby;
    const int wysokoscSzyby;

};

#endif   /* SZYBA_H */

Dla ścisłości - w temacie chodziło Ci zapewne o konstruktor kopiujący.

[Pneumokok]

W pliku Okno.cpp załączaj oba nagłówki (Okno.h i Szyba.h). W pliku Okno.h(...)

Dziękuję za pomoc - mam jeszcze jedną małą prośbę, mógłbyś wyjaśnić czemu akurat tak? Problem odpowiedniego załączania plików do siebie pewnie mi się powtórzy, a jak się człek raz porządnie nauczy to mniej potem zachodu

Dla ścisłości - w temacie chodziło Ci zapewne o konstruktor kopiujący.

Właśnie nie - chodziło mi o konstruktor konwertujący, czy właściwie o konwersję konstruktorem - jaką Grębosz w Symfonii opisuje w II tomie, na str. 686: ,,18.2.2 Przykład konwersji konstruktorem".
Przy czym konstruktor

Kod: Zaznacz cały

Okno::Okno(const Szyba szyba)

Nie robi być może nic charakterystycznego co winien taki konstruktor robić i na jedno by wyszło gdyby uznać go za kopiujący(lecz by był kopiujacy nie musi przypadkiem dostać referencji do oryginału zamiast kopii?).
Kod:

Ukryta treść:    

Kod: Zaznacz cały

Szyba szybka=szyba;
(...)
Okno oknoBezramkowe=szybka;

Zdaje się działać poprawnie, jest więc konwersja - choć być może nie jest ona senso stricte konieczna.

[Afish]

W pliku Okno.cpp załączaj oba nagłówki (Okno.h i Szyba.h). W pliku Okno.h(...)

Dziękuję za pomoc - mam jeszcze jedną małą prośbę, mógłbyś wyjaśnić czemu akurat tak? Problem odpowiedniego załączania plików do siebie pewnie mi się powtórzy, a jak się człek raz porządnie nauczy to mniej potem zachodu

Okno.cpp będzie wyciągało na przykład prywatne pola klasy Szyba, więc musi wiedzieć, co i jak może uzyskać - do tego potrzebuje deklaracji pól i metod, czyli najprościej załączyć nagłówek.

Dla ścisłości - w temacie chodziło Ci zapewne o konstruktor kopiujący.

Właśnie nie - chodziło mi o konstruktor konwertujący, czy właściwie o konwersję konstruktorem - jaką Grębosz w Symfonii opisuje w II tomie, na str. 686: ,,18.2.2 Przykład konwersji konstruktorem".
Przy czym konstruktor

Kod: Zaznacz cały

Okno::Okno(const Szyba szyba)

Nie robi być może nic charakterystycznego co winien taki konstruktor robić i na jedno by wyszło gdyby uznać go za kopiujący(lecz by był kopiujacy nie musi przypadkiem dostać referencji do oryginału zamiast kopii?).
Kod:

Ukryta treść:    

Kod: Zaznacz cały

Szyba szybka=szyba;
(...)
Okno oknoBezramkowe=szybka;

Zdaje się działać poprawnie, jest więc konwersja - choć być może nie jest ona senso stricte konieczna.

Okej, być może w polskiej nomenklaturze jest to konstruktor konwertujący, mi kompilator krzyczał o copy constructor, więc stąd moja uwaga. Najwyraźniej to Ty masz rację.

[Pneumokok]

Ok, już wszystko wiem. Dziękuję jeszcze raz za pomoc A sam temat do zamknięcia.