initialiser list

hi

auszug aus meinem code:

class Node
	{
		// ...
		NodeType _nt;
		union
		{
			struct
			{
				Node *_lhs, *_rhs;
			} _ptrpair;
			ValueType _val;
		} _d;
		// ...
	}

nun biete ich mehrere konstruktoren an, mit denen jeweils der eine oder der andere teil der union genutzt werden. ich hab versucht einen der konstruktoren zu schreiben, der dann etwa so aussah:

InterpretedMath::Node::Node()
: _nt(ntValue), _d._val(0)
{
}

mit diesem _d._val war der compiler aber gar nicht einverstanden. auszug aus der ideone.com-meldung:

prog.cpp: In constructor ‘InterpretedMath::Node::Node()’:
prog.cpp:57:19: error: expected ‘(’ before ‘.’ token
: _nt(ntValue), _d._val(0)
^

wie sonst soll das gehen? darf ich also die initialiser list nicht nutzen?
gruss

Skym0sh0

Die Snytax ist an sich richtig. Aber wo ist die Variable ntValue deklariert? Es ist ja kein Parameter des Konstruktors...

Bashar

Du kannst nur Member der aktuellen Klasse initialiseren. Du müsstest also wenn schon _d initialisieren. Ich hab keine Ahnung, ob das geht, aber da unions sowieso nur POD enthalten dürfen (wie auch bei dir), vergibst du nichts, wenn du erst im Konstruktor-Body eine Zuweisung machst.

InterpretedMath::Node::Node()
: _nt(ntValue)
{
    _d._val = 0;
}

Skym0sh0 schrieb:

Die Snytax ist an sich richtig.

In welcher Sprache?

Sone

Jetzt bin ich stark verwirrt. Mir sieht die Syntax völlig falsch aus, wieso, Skym0sh0, sagst du dass sie richtig ist?
Edit: Thx, Bashar.

ntValue ist ein status des enums NodeType, hab ich vergessen zu erwähnen, sry

der fehler tritt aber weiter hinten in der inizialisierungsliste auf, da steht ja so ein ^ mit welchem der ort markiert ist. (ups, sehe grad, dass das forum die whitespaces weggemacht hat es war ursprünglich direkt unter dem punkt nach _d)

okay, zwei neue posts während ich meinen letzten geschrieben habe. alles klar nun, danke.

Skym0sh0

Echt jetzt?

Ich dachte, das geht so ohne Probleme. Mit Unions hab ich keine Erfahrung, sosnt wärs mir aufgefallen.

Naja ok, danke Leute. (Ich sollte echt mehr denken und genauer lesen bevor ich schreibe)

camper

An dieser Stelle wäre es schön, wie in C die zu initialisierenden Member direkt in der Aggregat-Initialisierungsliste angeben zu können.
In C++11 können wir uns auch anders behelfen (ideone):

struct Node;
using ValueType = int;

union d_type
{
    struct
    {
        Node *_lhs, *_rhs;
    } _ptrpair;
    ValueType _val;

    d_type() noexcept = default;
    d_type(const d_type&) noexcept = default;
    d_type(d_type&&) noexcept = default;
    d_type& operator=(const d_type&) noexcept = default;
    d_type& operator=(d_type&&) noexcept = default;
    ~d_type() noexcept = default;

    d_type(const ValueType& v) noexcept
    {
        _val = v;
    }
    d_type(Node* lhs, Node* rhs) noexcept
    {
        _ptrpair = { lhs, rhs };
    }
};

d_type a{ nullptr, nullptr };
d_type b{ 0 };
int main(){}

Das ist damit kein Aggregat mehr, ist aber weiterhin trivial und hat Standardlayout, lowlevel-Schweinereien funktionieren also i.d.R. weiterhin.