void fooclass::foo1()
{
	int a = getA();

	switch (a)
	{
	case 1:
		ptr = &some_value;
		break;

	// ... 10 andere Fälle

	default:
		std::cout << "(EE) Invalid!\n";
	}
}

void fooclass::foo2()
{
	int a = getA();

	switch (a)
	{
	case 1:
		val = some_value;
		break;

	// ... 10 andere Fälle

	default:
		std::cout << "(EE) Invalid!\n";
	}
}

Ich hoffe ich habe mein Problem einigermaßen verständlich umrissen.

Danke im Voraus
MfG Cox (ohne Schlussfloskel wirkt sowas einfach plump(er) )

void fooclass::foo( bool instance )
{
	int a = getA( );

	if( instance )
	{
		switch (a)
		{
			case 1:
		    ptr = &some_value;
            break;

            // ... 10 andere Fälle

	        default:
            std::cout << "(EE) Invalid!\n";
			break;
    }
	else
	{
		 switch (a)
		 {
			 case 1:
             val = some_value;
             break;

             // ... 10 andere Fälle

             default:
             std::cout << "(EE) Invalid!\n";
			 break;
    }
};

(Ungetestet) Nur so eine Idee...

@lagalopex:
a ist bei beiden Methoden unterschiedlich, die anderen 10 Fälle unterscheiden sich in some_value bzw. &some_value.
Wobei es sich im eigentlichen Programm nicht um eine Variable sondern um ein paar unterschiedliche assoziative Container handelt, die ich je nach a verschieden behandeln will.
foo1 und foo2 werden nacheinander aufgerufen. Der Grund, warum ich dann überhaupt 2 Methoden verwende, ist einfach der, dass beide Codeabschnitte ca. 30 Zeilen lang sind, und ich 60 Zeilen in einer Funktion gern vermeiden würde. Das ganze auf eine Methode zu kürzen würde mich halt reizen, aber ich weiß eben nicht wie.

Ich bin mir einfach unsicher, wie ich es handhaben sollte.

@OhneName:
Wird leider nicht möglich sein, da val und *ptr nicht den selben Wert darstellen, und die Operation die ich mit val und ptr durchführe ebenfalls situationsabhängig ist. Ein wenig dämlich zu erklären ohne euch mit Code zu erschlagen.

void fooclass::foo(bool copy)
{
	irgendeintyp *tmpptr;

	switch (getA()) 
	{ 
	case 1:	tmpptr = &some_value; 
		break; 

	// ... 10 andere Fälle 

	default:std::cout << "(EE) Invalid!" << std::endl;
		return;
	}

	if (copy)
		val = *tmpptr;
	else
		ptr = tmpptr;
}

Wobei mir das ganze etwas merkwürdig erscheint...

bb

void fooclass::set_ptr()
{
	type t = classify(string);

	switch (t)
	{
	case type1:
		ptr = &map1[string];
		break;

	case type2:
		ptr  = &map2[string];
		break;

	case type3:
		ptr  = &map3[string];
		break;

	case type4:
		ptr = NULL;

	default:
		std::cerr << "(EE) Invalid!\n";
	}
}

void fooclass::set_val()
{
	type t = classify(string);

	switch (t) 
	{
	case type1:
		val = map1[string];
		break;

	case type2:
		val = map2[string];
		break;

	case type3:
		val = map3[string];
		break;

	case type4:
		val = 0;

	default:
		std::cerr << "(EE) Invalid!\n";
	}
}

Ich bin gerade am Überlegen, ob es nicht sinnvoller wäre, die 3 maps zusammenzulegen, eventuell in eine zweidimensionale Map / Vektor und direkt mit den Konstanten als Indices arbeiten. Die &map [...] / map[...]-Problematik löst sich dadurch aber leider auch nicht in Luft auf. Bin mir aber auch hier unsicher.

bb

@OhneName:
Wird leider nicht möglich sein, da val und *ptr nicht den selben Wert darstellen, und die Operation die ich mit val und ptr durchführe ebenfalls situationsabhängig ist. Ein wenig dämlich zu erklären ohne euch mit Code zu erschlagen.

So langsam glaub ich selbst nicht mehr dran, aber mein Sourcecode sagt das eindeutig aus...

bb

Die Überlegung mit den zweidimensionalen Maps wäre natürlich immernoch möglich. Oder du baust den switch so um, dass er abhängig von classify() einfach eine Referenz auf die richtige map liefert, vorausgesetzt die haben alle den selben Typen (was ja der Fall zu sein scheint).

Vielen Dank euch allen für die wie immer schnellen, netten und nicht zuletzt sehr hilfreichen antworten