Methoden zusammenfassen

lagalopex

Dann gib mal etwas mehr Informationen:
Wann wird foo1 und wann foo2 aufgerufen?
Kann man evtl beides (val und ptr) auf einemal setzen?
Wodrin unterscheiden sich die "10 anderen Fälle"? ptr? some_value?

OhneName

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

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

	// ... 10 andere Fälle

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

    // Wie wär's damit?
    val = *ptr;
}

@Troll: Da wird aber jemand seinem Namen gerecht

@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.

lagalopex

Evtl. so:

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...

unskilled

ich würde gerne mal die fkt., genau so wie sie jetzt sind, sehen. sind nur 60 zeilen oder so und man hat die chance, zu verstehen, was du brauchst^^

bb

Ok, ok
Wobei "10 Andere Fälle" ein wenig übertrieben war...entschuldigt aber bitte, wenn ich das ganze in Bezug auf Namensgebung trotzdem verallgemeinere.

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.

unskilled

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; 
        break; //

    default:
        throw std::invalid_argument("EE bla");
    } 

	if(ptr)
		val = *ptr;
	else
		val = 0;
}

bb

Cox schrieb:

@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...

unskilled

du hattest oben auch mal von nem array of maps geredet - ich würds so machen, wenn die maps die gleichen typen haben - und das scheint ja so zu sein ^^
ich würd vector (bzw tr1::array) nehmen, dann bleibt der Zugriff in O(1), genau wie jetzt auch^^ allerdings hätte ich die einträge wahrscheinlich so und so gemischt und die nr. iwo in das objekt mit reingehauen, was die map speichert - bin ich mir zwar nich ganz sicher, ob ich das gemacht hätte, weil ich den sourcecode nicht kenn, aber zumindest hätte ich drüber nachgedacht

bb

pumuckl

valtype& fooclass::get_ref()
{
  type t = classify(string);
  switch (t)
  {
    case type1: return map1[string];
    case type2: return map2[string];
    /* ... */ usw.
  }
}

void fooclass::set_ptr()
{
  valtype& ref=get_ref();
  ptr = &valtype;
}

void fooclass::set_val()
{
  val = get_ref();
}

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).

Die Idee mit der Referenz ist super, danke pumuckl. Nichtsdestoweniger werde ich es mit einem Array of Maps probieren, ich glaube das ist komfortabler.

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