c++: keine passende Funktion für Aufruf, aber der Kandidat hat exakt die gleiche Signatur

g++ beschwert sich über

myclass.cxx:185: error: no matching function for call to 'IMyInterface::doSomething(const SomeClass*, unsigned int)'
IMyInterface.h:34: note: candidates are: virtual void IMyInterface::doSomething(const SomeClass*&, unsigned int)

wenn ich Anrufe,

m_instanceOfInterface->doSomething((const SomeClass*)0,(unsigned int)1);

Alle Zeiger auf warum? Es scheint mir, dass g++ ist zu sehen, dass genau die gleiche Signatur zwischen dem, was erklärt wird und was aufgerufen wird, aber trotzdem beschwert sich darüber, keine passende Funktion gefunden.

Kann ich nennen, im gleichen Zusammenhang, eine andere Funktion des IMyInteface, IMyInterface::doSomethingElse(float& p). Also irgendwie die const ist das problem?

Habe ich nicht übergeben den NULL-Zeiger und warf eine Konstante ganze Zahl, nur so zum Spaß... ursprünglich habe ich 

m_instanceOfInterface->doSomething((const SomeClass*)m_someDerivedClass,m_anInteger);

und bekam den gleichen Fehler. Also habe ich beschlossen, zu klären, Dinge, die mit g++, indem einige explizite Argumente. Ich kann Ihnen versichern, dass der NULL-Zeiger ist NICHT das problem - obwohl verständlich, wir alle duckte sich ein wenig, wenn man eine NULL übergeben wird mit const 🙂

  • Funktioniert es, wenn Sie den Mauszeiger vor dem Aufruf der Funktion? Ich meine const SomeClass* ptr = 0; und dann m_instance->doSomething (ptr, 1)
  • PS: bitte fügen Sie den funktionskopf (Deklaration in der header), könnte das helfen...
  • Das (d.h. die Schaffung Zeiger vor dem Aufruf) das problem gelöst! Aber warum g++ geben, wie kryptische Nachricht?
  • Es ist ein syntax Fehler, du hast vergessen eine Klammer. Auch, warum warf einen integer? Sie können nur sagen 1U.
  • SB: Oder nur 1 Punkt. Der compiler ist intelligent genug, um zu wissen, wie man werfe einen positiven int zu einem unsigned int.
  • template <typename T> foo(T, T); unsigned int bar(); foo(bar(), 1); 🙁
  • Die Fehlermeldung macht es so Aussehen, als wenn es nur einen Kandidaten, wobei unsigned int. Aber es ist zumindest möglich, dass die Fehlermeldung abgeschnitten wurde, nur um zu zeigen die Kandidaten, dass der Fragesteller denkt, sollten aufeinander abgestimmt werden, und es gibt auch eine int überlastung. Oder werden in Zukunft. Nicht, dass Sie oft sorgen über solche Dinge, aber es wäre falsch zu vermuten, dass 1 wird es immer tun.
  • Sie können auch dieses Problem beheben, indem die Deklaration der Funktion wie doSomething(const SomeClass *const &, unsigned int). Auch müssen Sie nicht die const beim ausspielen von 0 bis SomeClass * (obwohl es nicht schadet)

InformationsquelleAutor polyglot | 2011-08-31
  1. 6

    Benötigt die Funktion das argument von nicht-const-Referenz, die nicht binden können, um eine temporäre. Beachten Sie:

    void foo(int, T &);
foo(1, T()); //error, cannot bind to temporary

    In deinem Fall T = SomeClass const *. Also, Sie haben eine nicht-temporäre:

    SomeClass const * pc = 0;
m_instanceOfInterface->doSomething(pc, 1U);

    Beachten Sie, dass der Zweck dieser ist es vermutlich zu füllen pc mit einigen sinnvollen Wert, so sicher zu integrieren, dass apporpriately.

    • Das temporäre problem ist der Kopf! Es scheint ein sehr subtiles problem, aufpassen... Sie haben mehr Bezug zu, warum es nicht umgesetzt wird auf diese Weise in den compiler?
    • Das ist eigentlich ziemlich straight-forward: die Übergabe eines non-const-Referenz bedeutet, dass Sie beabsichtigen, das Objekt ändern (denn sonst könnten Sie bestanden haben, die eine const-Referenz). Aber wenn Sie eine temporäre, alle änderungen gehen verloren, sofort am Ende der Zeile! Während das wäre nicht streng unmöglich zu implementieren, wäre es nur nie sein, nützlich und fast immer falsch, so dass die Sprache verbietet es.
    • es ist im Grunde, weil die Menschen, die schrieb die Sprache, dachte es wäre hilfreich für void doSomething(unsigned int &a) { a += 1; } zu einem Fehler führen, wenn Sie versuchen, es zu nennen, wie doSomething(1); oder sogar doSomething((unsigned int)1);. Dieser Aufruf ändern würde, eine temporäre, das wird sofort verworfen, und es wurde angenommen (zu Recht oder zu Unrecht), dass dies nicht das ist, was du meinst zu tun. Es ist besonders fehleranfällig, da ruft es wie int i = 1; doSomething(i); verlassen würde i gleich 1 ist, in der Erwägung, dass unsigned int i = 1; doSomething(i); würde eigentlich Inkrement i. Bugtastic.
    • eigentlich ist verbindlich, eine nicht-const Referenz auf ein temporäres einen möglichen Einsatz. Es wäre damit eine Funktion wie, sagen wir, time() (oder irgendetwas anderes mit einem optionalen aus-param), um einen Referenz-parameter anstelle von Zeiger-parameter und übergeben Sie in einem temporären anstelle von null, wenn Sie kümmern sich nicht um das Ergebnis, und die Implementierung muss nicht speziellen-Fall null-oder bieten überlastungen, um die parameter formal optional. So ist es nur fast nutzlos, eher als nie nützlich, und ich vermute, dass der potentielle nutzen nicht betrachtet überwiegen die wahrscheinlichen Fehler.
    • Aber die Funktion, die Unterschrift erklärt const, so der Anrufer, sollten Sie nicht erwarten, dass die parameter zu ändern, obwohl der Parameter wird per Referenz übergeben?
    • Ich denke, das, was ich meinte, ist, dass "es gibt immer einen Weg, um design eine Funktion, in der die übergabe eines veränderbaren temporären nutzlos ist". Der Umgang mit legacy code ist ziemlich plausibel eine Ausnahme. Sie könnte sich auch vorstellen, eine Funktion, die Sie brauchen, um passieren eine Referenz auf ein Speicher, in dem die Funktion tut seine Arbeit aber die ist es nicht notwendig, danach wieder... int x = compute(char[100]()); etc...
    • Kein Aspekt der Funktion der Unterschrift erklärt sich alles andere als const. Der Typ des ersten Arguments ist ein Verweis auf ein Zeiger auf ein konstantes Objekt, aber das hat nichts zu tun mit der constness des Zeigers selbst, oder der Funktion.
    • zu sichern, was Kerrek sagte nur, beachten Sie, dass void doSomething(const SomeClass* &ptrref, unsigned int) { ptrref = 0; } gültig ist, wird der Zeiger vom Aufrufer bereitgestellte, auf null. ptrref einfach nicht const. Es ist möglich, dass Sie gemeint zu erklären, dass der parameter entweder als SomeClass * const & oder als const SomeClass *const &, obwohl es nicht viel Sinn, die übergabe einer const-Referenz auf einen Zeiger, da Zeiger ist eine kleine Art, Sie könnte genauso gut gehen Sie von Wert für die meisten Zwecke.

    InformationsquelleAutor Kerrek SB
  2. 3

    Bearbeiten

    Korrigiert zu reflektieren Kommentare.

    Der Kandidat nicht haben genau die gleiche Signatur. Die Funktion übernimmt eine Referenz auf ein const-Zeiger auf eine SomeClass, und Sie sind die Zeiger. In der Tat, Sie bieten eine besonders Fiese Zeiger auf die Funktion.

    Ein großes problem ist hier, dass null-Zeiger. Müssen Sie dem compiler etwas fester, so kann er den Bezug von it. Sie geben einen null-Zeiger.

    • Ist es möglich, ein NULL Referenz (non-const)? Es scheint in den meisten Fällen sollten Sie versuchen, dass, wäre es zu einem compiler-Fehler, anstatt Undefiniertes Verhalten. Vielleicht habe ich einfach nicht gedacht habe, nichts.
    • Die Funktion übernimmt eine Referenz auf einen Zeiger, nicht ein Zeiger auf eine Referenz.
    • Der Grund, ich war vorbei, eine NULL und eine Konstante unsigned int ist, weil g++ ist mir, dass der Fehler für eine legitime Ruf. Ich veränderte die Frage, um die original-Aufruf.
    • Leider, ja. Es ist natürlich UB, aber das bedeutet nicht, es ist nicht möglich.
    • Sie sind richtig, natürlich. Diese komplexe Deklarationen werden müssen, Lesen von rechts nach Links für den größten Teil. Die Funktion erwartet eine Referenz auf einen const-Zeiger. Korrigiert, danke.
    • NULL-Zeiger ist nicht das problem (nicht der compiler sowieso). Siehe edits in Frage zu stellen.
    • Das problem ist, dass es eine temporäre, nicht, dass es null. const SomeClass *ptr = 0; doSomething(ptr, 1); ist erlaubt, auch wenn ptr null ist, vorausgesetzt natürlich, dass doSomething nicht dereferenzieren es durch das schreiben *ptr. SomeClass *ptr = new SomeClass; doSomething((const SomeClass *)ptr, 1); ist nicht erlaubt, auch wenn (const SomeClass *)ptr ist nicht null, weil das Ergebnis aus einem Guss (nicht-Referenz-Typ) ist eine vorübergehende.
    • Hammen ich denke, dass Steve ' s Kommentar ist das erste, was ich gefragt wurde. Es scheint, wie die nächste Sache, die Sie bekommen konnte, um eine NULL Verweis, der wirklich kompiliert wäre eine Referenz auf einen Zeiger, Punkte zu NULL -- das ist nicht UB, bis Sie wirklich dereferenzieren es. Ich denke, dass ich falsch interpretiert. 🙁

    InformationsquelleAutor David Hammen
  3. 2

    Ihre Funktion benötigt ein nicht-const Referenz auf einen Zeiger, nicht ein Zeiger. Sie können nicht erstellen Sie eine non-const Referenz aus einem literal (d.h. der null-Zeiger), damit der compiler nicht in der Lage ist, um die Funktion aufzurufen, die mit dem ersten argument '0' und er sucht sich eine überlastung der Einnahme das erste argument (der Zeiger) kopieren.

    InformationsquelleAutor Nicolas Grebille
Schreibe einen Kommentar