Jak sprawdzić czy struktura została zainicjalizowana

Jak mogę w elegancki sposób sprawdzić czy struktura została zainicalizowana?

struct PageSize
{
	public:
		int x;
		int y;
		_HPDF_PageSizes size;
		_HPDF_PageDirection direction;
};

class Document
{
	private:
		PageSize page_size;
		/*...*/
	public:
		PageSize getPageSize( return page_size;)
}

int main() 
{
	Document doc;
	//if (doc.getPageSize()==NULL) do_something;

gdzie _HPDF_PageSizes i _HPDF_PageDirection to typy wyliczeniowe. Jedyna myśl jaka mi przychodzi do głowy to przeciążyć operator== aby porównać go z NULLem. Np:

bool operator== (const PageSize& p1, const int& null )
{
	return (p1.direction == null && p1.size == null && p1.x == null && p1.y == null);
}

1. Składowe struktury są domyślnie publiczne.

2. Możesz nadać polom struktury wartości domyślne za pomocą inicjatorów wewnątrzklasowych i potem porównywać z wartością domyślną:

struct PageSize {
    int x = 0;
    int y = 0;
    _HPDF_PageSizes size = static_cast<_HPDF_PageSizes>(0);
    _HPDF_PageDirection direction = static_cast<_HPDF_PageDirection>(0);
};

3. Pamiętaj, że w C++ struktura to rodzaj klasy z domyślnie publicznymi składowymi. Możesz mieć zatem konstruktory, destruktory, metody, itp.

4. Rozważ użycie enum class zamiast enuma, aby nie zaśmiecać przestrzeni nazw.

Nie używaj nulla, jest 2018 rok, od 2011 mamy coś takiego: https://en.cppreference.com/w/cpp/language/nullptr

Nie pokazałeś póki co żadnego konstruktora, ciężko zatem nawet określić jak ta struktura miałaby być inicjalizowana.
Linijka:

Document doc;

tworzy obiekt ale nie gwarantuje, że cokolwiek zostanie zainicjowane, ani że będzie nullem.

mlp99 napisał(a):

Jak mogę w elegancki sposób sprawdzić czy struktura została zainicalizowana?

Zgadzam się z kolegami, zrobić dobrze a nie sprzątać. Konstruktor i wszystko jasne.
Wydaje się ten tok myślenia jest w stylu C.

... struktura została zainicalizowana?

odróżniasz przypadki "prawidłowo zainicalizowana" i "zainicalizowana ale nie do pracy" (te wartości domyślne o jakich piszą koledzy) ?
Warto pomedytowac nad samą ideą..

Warto też pomedytować nad obiektami niezmiennymi (immutable). Zainicjowane raz a dobrze. W świecie C++ nie jest to często dyskutowane, ale przemyśleć warto.

Pomijając zasadność i inne błędy

Jak mogę w elegancki sposób sprawdzić czy struktura została zainicalizowana?

Przeciążyć operator bool, np:

struct Type
{
       std::unique_ptr<direction> val;
       operator bool() { return val != nullptr;}
};

Type getPageSize(){....};

int main()
{
    auto pageSize = getPageSize()
    if(pageSize)
    {
         / / .....
    }
}

several napisał(a):

Pomijając zasadność i inne błędy

Jak mogę w elegancki sposób sprawdzić czy struktura została zainicalizowana?

Przeciążyć operator bool, np:

struct PageSize
{
       _HPDF_PageDirection direction;
       operator bool() { return director != nullptr;}
};

PageSize getPageSize(){....};

int main()
{
    auto pageSize = getPageSize()
    if(pageSize)
    {
         / / .....
    }
}

To się nie uda, dałeś tylko syntactic sugar.
Po pierwsze dane niezainicjowane mają wartość przypadkową (w tym, i nieskromnie uważam, to częściej niż statystycznie, na zera)
Po drugie, dla ilustracji, wersje debugowane mogą/inicjują wartością magiczną, np 0xCE

@AnyKtokolwiek @janusz_h4ck3r 1337 w swoim poście chciałem tylko odpowiedzieć na postawione i zacytowane pytanie, nie zamierzałem rozwiązywać innych problemów. Nie wiem czym są typy użyte przez autora. Poprawiłem tak, żeby nie było błędów.

Nie rozumiem, co konstruktor ma tutaj do rzeczy, ale wygląda on tak:

struct PageSize
{
	PageSize();
	PageSize(int x, int y, _HPDF_PageSizes size, _HPDF_PageDirection direction) { this->x = x, this->y = y, this->size = size, this->direction = direction; }
	int x = 0;
	int y = 0;
	_HPDF_PageSizes size = static_cast<_HPDF_PageSizes>(0);
	_HPDF_PageDirection direction = static_cast<_HPDF_PageDirection>(0);
};

Problem polega na tym, że nie za każdym razem tworząc obiekt Document będę inicjował strukturę PageSize wartościami. W zależności od tego czy stuktura będzie zainicjowana czy nie, będę wykonywał inne czynności w dalszej części programu. _HPDF_PageSizes i _HPDF_PageDirection są enum'ami z biblioteki libharu, które określają rozmiar strony oraz orientację.
I tak jeszcze tak btw. zainicjowanie czy zainicjalizowanie, bo spotykam się z dwoma wersjami naprzemiennie i już nie wiem, która jest poprawna

Brunatny Kret napisał(a):

Nie rozumiem, co konstruktor ma tutaj do rzeczy, ale wygląda on tak:

To nie rozumiem z czym masz problem.

Problem polega na tym, że nie za każdym razem tworząc obiekt Document będę inicjował strukturę PageSize wartościami. W zależności od tego czy stuktura będzie zainicjowana czy nie, będę

Posiadając konstruktor będzie zainicjowana. Lepiej lub gorzej, jak ci juz tłumaczyłem.

I tak jeszcze tak btw. zainicjowanie czy zainicjalizowanie, bo spotykam się z dwoma wersjami naprzemiennie i już nie wiem, która jest poprawna

obie są tutaj zrozumiałe, rzeczywiście jest z tym słowem na gruncie j.polskiego jakiś drobny problem.

Dodaj do swojej struktrury jakiegoś boola, który będzie ustawiany na true lub false w zależności od tego jakiego konstruktora użyjesz.

Moja wina. Źle się wyraziłem, ale dopiero teraz zauważyłem, że pomyliłem pojęcia. Tzn rozumiem, że przy każdym stworzeniu obiektu klasy Document wywoła mi się konstruktor struktury (chociażby domyślny) i mi zainicjuje pola wartościami 0. A mój problem (który chyba rozwiązał @several ) polegał na tym, że muszę sprawdzić nie tyle, że struktura została zainicjowana, ile to czy ma wartości domyślne czy też nie. Jeśli nie to znaczy że został użyty konstruktor PageSize(int x, int y, _HPDF_PageSizes size, _HPDF_PageDirection direction) Ok. W zwiazku z powyższym myślę, że prawidłowym rozwiązaniem będzie faktycznie przeciężenie operatora bool() i zrobienie czegoś takiego:

	operator bool()
	{
		if (x == 0 && y == 0 && size == static_cast<_HPDF_PageDirection>(0) && direction == static_cast<_HPDF_PageSizes>(0)) return false;
		else return true;
	}