gibt es eine Möglichkeit, einen Funktionsparameter auch aus einer = Zuweisung zu erhalten ?

statt:

variable.set("a",2.3);

möchte ich sowas machen können:

variable.set("a")=2.3;

grüße aus Peine Mirko

Mit ner Referenz. Aber nicht gerade eine schöne Sache.

Nicht, wenn du den Wert (hier 2.3) in der Funktion benutzen möchtest. Warum sollte man so etwas wollen? Benutz die Sprache so, wie sie gedacht ist.

Ist doch übersichtlicher mit der = Zuweisung. Da weis jeder der den Code sieht was geschehen soll.
Ich möchte "a" den Wert 2.3 zuweisen.

class int_
{
private:
    int _int;

public:
    int get() const
    {
        return _int;
    }

    int& set()
    {
        return _int;
    }
};

int main()
{
    int_ foo;
    foo.set() = 12;
}

Mit ner Referenz. Aber nicht gerade eine schöne Sache.

So komme ich aber nicht in der Funktion set an die 12 ?

Ich möchte "a" den Wert 2.3 zuweisen.

Ganz genau, das willst du, tust es aber nicht. Deine Funktion heißt set , du übergibst ihr aber kein Wert. Wie will man etwas setzen ohne etwas zu haben? Da denkt man sich nur, WTF.

Es ziehet von dannen,
Der Alchimist

#include <iostream>
#include <stdexcept>

using namespace std;

template<typename T1, typename T2> class cVar
{
    private:
        static const int ARR_MAX=99;
        T1 _v1[ARR_MAX];
        T2 _v2[ARR_MAX];
        int _index;

    public:

        cVar():_index{0}
        {

        }

        void add(T1 v1,T2 v2)
        {
            if (_index>=ARR_MAX) throw logic_error("array zu klein.");
            _v1[_index] = v1;
            _v2[_index] = v2;
            _index++;
        }

        T2 get(T1 v1)
        {
            for (int i=0;i<_index;i++)
                if ( _v1[i]==v1 ) return _v2[i];

            throw logic_error("'" +v1+ "' nicht gefunden.");
        }

        void set(T1 v1,T2 v2)
        {
            for (int i=0;i<_index;i++)
            {
                if ( _v1[i]==v1 ) _v2[i]=v2;
                return;
            }

            throw logic_error("'" +v1+ "' nicht gefunden.");

        }

        T2& set2(T1 v1)
        {
            return _v2[0];
        }

};

int main()
{

    cVar<string,double> nvars;
    nvars.add("a");
    nvars.add("b",1.2);

    nvars.set("a",2.3);

    // todo: sowas wäre schön
    // nvars.set2("a")=2.3;

}

T2& get(T1 v1)
        {
            for (int i=0;i<_index;i++)
                if ( _v1[i]==v1 ) return _v2[i];

            throw logic_error("'" +v1+ "' nicht gefunden.");
        } 

...

nvars.get("a")=2.3;

compiliert er zwar, aber ich möchte ja die 2.3 meinem array von T2 zuweisen

Schau dir mal an, wie die std::map aufgebaut ist.

ja kenne ich. statt ["a"]=2.3 möchte ich aber foo("a")=2.3

ja kenne ich. statt ["a"]=2.3 möchte ich aber foo("a")=2.3

Ändert ja nichts am grundlegenden Prinzip. Beides sind Memberfunktionen.

<>

compiliert er zwar, aber ich möchte ja die 2.3 meinem array von T2 zuweisen

tu ich doch. Am Ende steht an der Position für die _v1[i]=="a" gilt, dass _v2[i]=2.3

offensiv schrieb:

compiliert er zwar, aber ich möchte ja die 2.3 meinem array von T2 zuweisen

tu ich doch. Am Ende steht an der Position für die _v1[i]=="a" gilt, dass _v2[i]=2.3

Er ist verwirrt, weil da get und nicht set steht.

template<typename T1, typename T2> class cVar
{
    private:
        static const int ARR_MAX=99;
        T1 _v1[ARR_MAX];
        T2 _v2[ARR_MAX];
        int _index;

    public:
        cVar() : _index(0)
        {
        }

        void add(T1 v1,T2 v2)
        {
            if (_index>=ARR_MAX) throw logic_error("array zu klein.");
            _v1[_index] = v1;
            _v2[_index] = v2;
            _index++;
        }

		T2 get(T1 v1)
        {
            for (int i=0;i<_index;i++)
                if ( _v1[i]==v1 ) return _v2[i];
            throw logic_error("'" +v1+ "' nicht gefunden.");
        }

        T2& set(T1 v1)
        {
            for (int i=0;i<_index;i++)
                if ( _v1[i]==v1 ) return _v2[i];
            throw logic_error("'" +v1+ "' nicht gefunden.");
        }
};

int main()
{
    cVar<string,double> nvars;
    nvars.add("b",1.2);
	nvars.set("b")=2.3;
	cout << endl << nvars.get("b");
}

ja so gehts. Ist mir blos noch nicht klar wieso

Was verstehst du dennnicht genau?

Ja, habs mir nochmal durch den Kopf gehen lassen. Mir war nicht klar,
das ich einem Referenz-Return-Value aus einer Funktion wieder direkt etwas
zuweisen kann.

Habs halt sonst immer Klassisch

ref a=foo()
a=1.2

gemacht.

Das Problem was ich nun erkenne ist, das ich die Variable aus der Hand gebe.
Kann so zB keine Bereichsgrenzen meiner Variablen "b" überprüfen.

Hat jemand noch nen anderen Ansatz ?

Das Problem was ich nun erkenne ist, das ich die Variable aus der Hand gebe.
Kann so zB keine Bereichsgrenzen meiner Variablen "b" überprüfen.

Ja, nimm normale Set-Memberfunktionen. Sonst frickelst du dir eine mühsame Lösung zusammen, nur um schöne Syntax zu haben.

Sowas wie nvars.set("b")=2.3 ist ohnehin sehr ungewöhnlich. Falls jemand anders (oder du selbst nach einiger Zeit) diesen Code sieht, ist Verwirrung garantiert.

< >

offensiv schrieb:

Das Problem was ich nun erkenne ist, das ich die Variable aus der Hand gebe.
Kann so zB keine Bereichsgrenzen meiner Variablen "b" überprüfen.

Ja, nimm normale Set-Memberfunktionen. Sonst frickelst du dir eine mühsame Lösung zusammen, nur um schöne Syntax zu haben.

Sowas wie nvars.set("b")=2.3 ist ohnehin sehr ungewöhnlich. Falls jemand anders (oder du selbst nach einiger Zeit) diesen Code sieht, ist Verwirrung garantiert.

< >

yes sir! Werde ich so machen. Aber mein Interpreter wird dieses Konstrukt übersetzen

Vielen Dank an Alle für die Denkansätze.

Kann so zB keine Bereichsgrenzen meiner Variablen "b" überprüfen.

Bau dir einen Wrapper (als Klasse), der die Bereichsgrenzen prueft..