Dziedziczenie klas/struktur (formaty floata)

Question

Cześć.

#include <iostream>
#include <memory>
#include <bitset>

using cuint = const unsigned int;

class precision_format{
    public:
    	constexpr precision_format(cuint s_off=0, cuint e_off=1, cuint m_off=0, cuint size=0) :
					SIGN_OFF(s_off), EXPONENT_OFF(e_off), MANTISSA_OFF(m_off), SIZE(size) {}
        const unsigned SIGN_OFF;
        const unsigned EXPONENT_OFF;
        const unsigned MANTISSA_OFF;
        const unsigned SIZE;
};

class s_precision_bin : public precision_format{
    public:
    	constexpr s_precision_bin(cuint m_off=9, cuint size=32) :
                                MANTISSA_OFF(m_off), SIZE(size) {}
        const int MANTISSA_OFF{9};
        const int SIZE{32};
};
constexpr static s_precision_bin single_p_fmt{};


class d_precision_bin : public precision_format{
    public:
    	constexpr d_precision_bin(cuint m_off=12, cuint size=64) :
                    MANTISSA_OFF(m_off), SIZE(size) {}
        const int MANTISSA_OFF{12};
        const int SIZE{64};
};
constexpr static d_precision_bin double_p_fmt{};

class e_precision_bin : public precision_format{
    public:
    	constexpr e_precision_bin(cuint m_off=16, cuint size=80) :
                    MANTISSA_OFF(m_off), SIZE(size) {}
        const int MANTISSA_OFF{16};
        const int SIZE{80};
};
constexpr static e_precision_bin extended_p_fmt{};


class color_format{
    public:
        explicit color_format(precision_format fpf) : fp_format(std::make_unique<precision_format>(fpf)) {}
        void bind(int, int, int);
		void dbg_print_pf(){
			std::cout<<fp_format->SIGN_OFF<<'\n'<<fp_format->EXPONENT_OFF<<'\n'
						<<fp_format->MANTISSA_OFF<<'\n'<<fp_format->SIZE<<'\n';
		}
    private:
        std::unique_ptr<precision_format> fp_format;
        int sign_c{0}; // nie wazne
        int exponent_c{9}; // useless
        int mantissa_c{123}; // jw
};


int main(){
	color_format cf(single_p_fmt);
	cf.dbg_print_pf();
}	

(To kod testowy, w normalnym kodzie wszystko ładnie rozdzielone itd.)
Próbuję sobie zrobić coś takiego co wyżej:

• klasa color_format przyjmuje któryś precision_format
• w konstruktorze bierze wskaźnik, coby móc użyć polimorfizm

Ale problem jest taki, że dbg_print_pf wypisuje mi 0 1 0 0, nie ważne jaki format się tam wyśle, co jednak jest pewnym problemem. Pewnie coś zepsułem w dziedziczeniu (oop to moja pięta achillesowa), prosiłbym o naprowadzenie.

Answer 1

Jeśli tworzysz konstruktor z dużą ilością argumentów domyślnych, to masz kod który potencjalnie tworzy Ci całe stado możliwych do wygenerowania konstruktorów. U Ciebie masz wszystkie argumenty domyślne, więc powstanie nawet konstruktor bez argumentów.

Masz jeszcze błąd związany z brakiem delegacji konstrukcji. W tym przypadku nie ma sensu tworzyć własnych pól w klasie potomnej, jeśli są ok w rodzicu.

Poprawiłem minimalne bo myślę że popełniłeś gdzieś błąd koncepcyjny. A całej koncepcji nie znam:

#include <iostream>
#include <memory>
#include <bitset>
 
using cuint = const unsigned int;
 
class precision_format{
    public:
        constexpr precision_format(cuint s_off=0, cuint e_off=1, cuint m_off=0, cuint size=0) :
                    SIGN_OFF(s_off), EXPONENT_OFF(e_off), MANTISSA_OFF(m_off), SIZE(size) {}
        const unsigned SIGN_OFF;
        const unsigned EXPONENT_OFF;
        const unsigned MANTISSA_OFF;
        const unsigned SIZE;
};
 
class s_precision_bin : public precision_format{
    public:
        constexpr s_precision_bin(cuint m_off=9, cuint size=32) :
                                precision_format{0, 1, m_off, size} {}
};
constexpr static s_precision_bin single_p_fmt{};
 
 
class d_precision_bin : public precision_format{
    public:
        constexpr d_precision_bin(cuint m_off=12, cuint size=64) :
                    MANTISSA_OFF(m_off), SIZE(size) {}
        const int MANTISSA_OFF{12};
        const int SIZE{64};
};
constexpr static d_precision_bin double_p_fmt{};
 
class e_precision_bin : public precision_format{
    public:
        constexpr e_precision_bin(cuint m_off=16, cuint size=80) :
                    MANTISSA_OFF(m_off), SIZE(size) {}
        const int MANTISSA_OFF{16};
        const int SIZE{80};
};
constexpr static e_precision_bin extended_p_fmt{};
 
 
class color_format{
    public:
        explicit color_format(const precision_format & fpf) : fp_format(std::make_unique<precision_format>(fpf)) {}
        void bind(int, int, int);
        void dbg_print_pf(){
            std::cout<<fp_format->SIGN_OFF<<'\n'<<fp_format->EXPONENT_OFF<<'\n'
                        <<fp_format->MANTISSA_OFF<<'\n'<<fp_format->SIZE<<'\n';
        }
    private:
        std::unique_ptr<precision_format> fp_format;
        int sign_c{0}; // nie wazne
        int exponent_c{9}; // useless
        int mantissa_c{123}; // jw
};
 
 
int main(){
    color_format cf(single_p_fmt);
    cf.dbg_print_pf();
}

 

Comments

Co to za zapis c-tor : parent_c-tor(args)? Ma jakąś nazwę w standardzie?
I czemu takie coś, a nie c-tor: exponent_off(e_off), mantissa_off(m_off)?
Kwestia bezpieczeństwa. wyglądu, czy czego?

Btw.
Jest to program, do wyjaśnienia floating pointów od środka (binarka) i potrzebuję zbindować do kolejnych "sekcji" (znak, wykładnik, mantysa) kolory, żeby to jakoś wyglądało, a więc mam coś takiego

---

Co to za zapis c-tor : parent_c-tor(args)? Ma jakąś nazwę w standardzie?

Delegacja konstruktora (pierwszy z brzegu wynik: https://arne-mertz.de/2015/08/new-c-features-inherited-and-delegating-constructors/ ). Żebyś jednak zrozumiał. Jeśli tego nie dasz, kompilator sam wywołuje Ci konstruktor rodzica. To jest przecież mechanizm dziedziczenia. Tylko jaki konstruktor? Ano konstruktor bez parametrów. Taki konstruktor możesz mieć bo wszystkie Twoje argumenty w rodzicu są domyślne.