es geht um folgendes:
Angenommen wir haben folgende Klasse:

class Bla {
public:
  operator () (int x) {
    cout << x << endl;
  }

  operator () (int x, int y, int z) {
    cout << x << y << z << endl;
  }
};

Soweit ja kein Problem. Ich möchte jetzt aber noch eine Operator Überladung mit einer undefinierten Parameteranzahl haben:

operator () (...) {
  __ asm { /*asm code*/ };
}

Das Problem ist jetzt, dass die Überladung nicht mehr eindeutig ist; der Compiler weiß nicht, ob er
operator() (...)
oder
operator() (int x)
aufrufen soll, wenn der Operator so benutzt wird:

int main() 
{
  Bla b;
  b(1);
}

Der Hintergrund ist mir klar. Gibt es jedoch nicht dennoch eine Möglichkeit dem Compiler mitzuteilen, welche im Zweifel die primäre/default Überladung ist?

Ich habe schon mit dem Gedanken gespielt einen Dummy Parameter zu übergeben (z.B: void* der dann auf NULL gesetzt wird), da bräuchte ich in diesem Beispiel aber schon 2 und das wäre mehr als hässlich.

Wäre super, wenn jemand eine Idee hätte

Soweit ja kein Problem. Ich möchte jetzt aber noch eine Operator Überladung mit einer undefinierten Parameteranzahl haben

Die einfache Antwort: Geht nicht.

Soweit ja kein Problem. Ich möchte jetzt aber noch eine Operator Überladung mit einer undefinierten Parameteranzahl haben:

operator () (...) {
  __ asm { /*asm code*/ };
}

Ui, das sieht nicht gut aus. Wie findest du in der Funktion denn raus, welche Typen die Parameter haben?

Der Hintergrund ist mir klar. Gibt es jedoch nicht dennoch eine Möglichkeit dem Compiler mitzuteilen, welche im Zweifel die primäre/default Überladung ist?

Geht nicht.

Ui, das sieht nicht gut aus. Wie findest du in der Funktion denn raus, welche Typen die Parameter haben?

Bitte solche Sachen einfach als Vorraussetzung sehen. Ich kann dir exakt sagen, welches Argument dann wie und wo auf dem Stack liegt und von welchem Typ es ist. Woher ich das weiß spielt hier keine Rolle.

Ich such halt einfach die Möglichkeit dass zu tun, was ich oben beschrieben habe. Mir ist klar, dass es so wohl nicht geht, aber vielleicht hat ja jemand von euch eine Idee, wie ich das trotzdem lösen könnte (z.B. mit einem zusätzlichen Parameter). Ich setze einfach mal auf eure Kreativität, denn aktuell fällt mir nichts "schönes" ein.

dann mach die anderen operatorfunktionen zu normalen (private) funktionen und wenn du mitkriegst das die andere funktion mit einem oder zwei parametern aufgerufen wurde dann rufst du die entsprechenden funktionen auf.

Ist eine ganz gute Idee. Nur leider werde ich nicht mitbekommen, ob da jemand was auf den Stack gepusht hat oder nicht.

Ich kann dir exakt sagen, welches Argument dann wie und wo auf dem Stack liegt und von welchem Typ es ist.

Heißt das du kannst es mir sagen, willst aber nicht? Ich würde es sehr gerne wissen, wenn du da eine interessante Lösung hast.

Ich setze einfach mal auf eure Kreativität, denn aktuell fällt mir nichts "schönes" ein.

Mir fällt da außer einem speziellen Typen als ersten Parameter nichts ein.

enum dummytype { blubb};
operator()(dummytype, ...) {...}

FrEEzE2046 schrieb:

Ich kann dir exakt sagen, welches Argument dann wie und wo auf dem Stack liegt und von welchem Typ es ist.

Heißt das du kannst es mir sagen, willst aber nicht? Ich würde es sehr gerne wissen, wenn du da eine interessante Lösung hast.

Wenn du wüsstest, in welcher Klasse es sich befindet, wie die Struktur ist etc. dann könntest du es nachvollziehen.

Ich will nicht unhöflich sein und es hat daher auch nichts damit zu tun, dass ich es dir nicht sagen will. Da der Code jedoch an der Arbeit entsteht, darf ich ihn leider nicht veröffentlichen.

operator() (); //null parameter
operator() (int); //wie gehabt
template <class T>
operator() (T); //spezielle form deines gewünschten op mit 1 Parametern
template <class T, class U>
operator() (T, U); //spezielle Form deines gewünschten op mit 2 Parametern
operator() (int, int, int); //wie gehabt
template <class T, class U, class V>
operator() (T, U, V); //spezielle Form deines gewünschten op mit 3 Parametern
template <class T, class U, class V>
operator() (T, U, V, ...); //dein gewünschter op mit 4 und mehr Parametern

die templates biegst du alle einfach auf eine memberfunktion um, die eine normale ellipse als Parameter hat. (btw: ellipsen sind pfui...)

#include <iostream>

struct foo
{
	void operator () (int a) { std::cout << "a\n"; }
	void operator () (int a, int b, int c) { std::cout << "a, b, c\n"; }
	void operator () (...) { std::cout << "...\n"; }
};

struct int_convertible
{
	operator int() const { return 123; }
};

struct long_convertible
{
	operator long() const { return 123; }
};

struct int_convertible_convertible
{
	operator int_convertible() const { return int_convertible(); }
};

int main(int argc, char** argv)
{
	foo f;
	f(1); // a
	f(1, 2); // ...
	f(1, 2, 3); // a, b, c
	f(1, 2, 3, 4); // ...
	f("..."); // ...
	f(foo()); // ...

	// selbst hier wird die "..." funktion schlechter bewertet
	f('a'); // a
	f(1.1); // a
	f(123ull); // a
	f(int_convertible()); // a
	f(long_convertible()); // a (zwei konvertierungen! allerdings nur eine user-defined, daher OK, und a wird gewählt)

	// das *geht* nichtmehr mit a, daher kommt "..." dran:
	// (zwei user-defined conversions hintereinander werden nicht berücksichtigt)
	f(int_convertible_convertible());

	return 0;
}

Ist zwar nicht gerade so, dass ich nicht wüsste, was ihm da missfällt. Ich würde jedoch gerne die Optimierung für diesen Code-Abschnitt ausschalten.

Ein

#pragma optimize( "", off )

hilft leider nicht.

Natürlich geht das. Bloss kannst du dir nicht aussuchen welche Funktion als besser bewertet und ausgewählt wird. Die "..." Funktion wird immer fix als schlechter bewertet, und kommt daher nur dran, wenn andere Funktionen nicht möglich sind

Bei mir sagt (oben genannter) Compiler:

error C3066: there are multiple ways that an object of this type can be called with these arguments

Ich habe allerdings auch noch einen (void) Fall!

Ist zwar nicht gerade so, dass ich nicht wüsste, was ihm da missfällt. Ich würde jedoch gerne die Optimierung für diesen Code-Abschnitt ausschalten.

Code in eine eigene Compilierungseinheit (sprich: cpp-Datei) auslagern und entsprechende Einstellungen fuer diese Datei vornehmen.

Und zu deinem ganzen Problem jetzt die nicht ganz so einfache Antwort: In C gibt es va_list, fuer C++ hier mit Beispielen: http://www.cplusplus.com/reference/clibrary/cstdarg/ .

Edit: Ich sehe aber grad, das hustbaer schon darauf verwiesen hat.

Code in eine eigene Compilierungseinheit (sprich: cpp-Datei) auslagern und entsprechende Einstellungen fuer diese Datei vornehmen.

Und zu deinem ganzen Problem jetzt die nicht ganz so einfache Antwort: In C gibt es va_list, fuer C++ hier mit Beispielen: http://www.cplusplus.com/reference/clibrary/cstdarg/ .

1. Was heißt entsprechende Einstellungen? Auch nach deaktivierten Optimierung kommt der Fehler.

2. Ich kann va_list, aber dass hat nicht direkt mit meinem Problem zu tun, oder worauf willst du hinaus?

Den parameterlosen Overload weglassen, so dass bei Aufruf ohne Parameter einfach die "..." Variante ausgewählt wird ginge für dich nicht?

Ist zwar nicht gerade so, dass ich nicht wüsste, was ihm da missfällt

Was misfällt ihm denn?

Den parameterlosen Overload weglassen, so dass bei Aufruf ohne Parameter einfach die "..." Variante ausgewählt wird ginge für dich nicht?

Nein, leider nicht. Ich kann per Assembler ja schlecht überprüfen, ob da was auf dem Stack liegt oder nicht (außer den lokalen Variablen versteht sich).

hustbaer schrieb:

Ist zwar nicht gerade so, dass ich nicht wüsste, was ihm da missfällt

Was misfällt ihm denn?

Hat nichts mit dem Thema hier zu tun, aber:
Mittlerweile kommt die Meldung nicht mehr, dennoch möchte er folgenden Code nicht compilieren:

template<class Container,
         typename R, typename P1,
		 R (Container::*Func)(P1)>

bei jedem Template Argument sagt er:

could not deduce template argument for 'R'  // das gleiche für P1 und Func

template<class Container,
         typename R, typename P1,
		 R (Container::*Func)(P1)>

bei jedem Template Argument sagt er:

could not deduce template argument for 'R'  // das gleiche für P1 und Func

Mangles code kann man wiedermal nur raten was da schief läuft. Meine Glaskugel mutmaßt dass du da ein Funktionstemplate hast und es ohne Angabe der Templateparameter aufrufst, und dass die Funktionsparameter nicht ausreichen um die Templateparameter herzuleiten.

Mangles code kann man wiedermal nur raten was da schief läuft. Meine Glaskugel mutmaßt dass du da ein Funktionstemplate hast und es ohne Angabe der Templateparameter aufrufst, und dass die Funktionsparameter nicht ausreichen um die Templateparameter herzuleiten.

Es existiert noch gar kein Code. Aber so lässt sich der Fehler generieren:

template<class Container,
         typename R, typename P1,
		 R (Container::*Func)(P1)>
blub()
{

}

//Aufruf:
class Bla {
public:
  int methode(int) {return 0;}

  void ui() {
    blub<Bla, int, int, &methode>();
  }
};

1. Was heißt entsprechende Einstellungen? Auch nach deaktivierten Optimierung kommt der Fehler.

Ich habe dir nur gesagt, wie man die Optimierung ausschaltet. Der Fehler wird durch deinen Quelltext verursacht und hat nichts mit Optimierung zu tun.

1. Was heißt entsprechende Einstellungen? Auch nach deaktivierten Optimierung kommt der Fehler.

Ich habe dir nur gesagt, wie man die Optimierung ausschaltet. Der Fehler wird durch deinen Quelltext verursacht und hat nichts mit Optimierung zu tun.

Warum kommt dann die Meldung vom Optimization Compiler?

blub<Bla, int, int, &Bla::methode>();

Warum kommt dann die Meldung vom Optimization Compiler?

Weil der Microsoft Compiler nunmal ein optimierender Compiler ist, auch wenn die Optimierungen abgeschaltet sind?

So wie ein Auto in der Lage ist zu fahren, auch wenn der Motor jetzt gerade mal ausgeschaltet ist.

Th69 schrieb:

Ich glaube, du mußt explizit die Klasse angeben, d.h.

blub<Bla, int, int, &Bla::methode>();

Vöölig richtig. Es gibt keine Funktion &methode (zumindest nicht im Beispiel). Nur &Bla::methode.

Der Compiler von Microsoft für die Sprachen C und C++ heißt nunmal (auf deutsch) "Microsoft C/C++-Optimierungscompiler".

Sehr gut nachzuvollziehen auch wenn Du cl.exe ohne Optionen startest.

"Microsoft C/C++-Optimierungscompiler".

rofl

Der compiliert also Optimierungen