Compiler Fehlermeldung soll auf fehlendes include hinweisen

SeppJ

gcc benutzen, der gibt eine aussagekräftige Fehlermeldung

volkard

Das geht ganz einfach:

// File H1_AddOn.h
// #include <..> // nested includes
class Reference
{
public:
    // Lieber Holger!
    // Wenn der Fehler 
    // error C2582: 'operator =' function is unavailable in 'Reference'
    // kommt, dann hast Du vermutlich vergessen, 
    // diese Datei hier zu inkludieren. 
    // Dein Werner
    template< typename T >
    Reference& operator=( const T& data )
    {
        // .. Code - spielt hier keine Rolle
        return *this;
    }
};

Ad aCTa

Wenn schon so, wäre dann das nicht besser?

// File H1.h
class Reference; // nur forward!
class Universal // wird sehr häufig benötigt
{
    // Lieber Holger!
    // Wenn der Fehler
    // error C2582: 'operator =' function is unavailable in 'Reference'
    // kommt, dann hast Du vermutlich vergessen,
    // "H1_AddOn.h" zu inkludieren.
    // Dein Werner
public:
    // .. viele Methoden usw.
    Reference Access( int idx ); // Zuweisungs-Wrapper (s.u.) wird selten benötigt
};

Werner Salomon

volkard schrieb:

Das geht ganz einfach:

// File H1_AddOn.h
// #include <..> // nested includes
class Reference
{
public:
    // Lieber Holger!
    // Wenn der Fehler 
    // error C2582: 'operator =' function is unavailable in 'Reference'
    // kommt, dann hast Du vermutlich vergessen, 
    // diese Datei hier zu inkludieren. 
    // Dein Werner
    template< typename T >
    Reference& operator=( const T& data )
    {
        // .. Code - spielt hier keine Rolle
        return *this;
    }
};

Nein, so einfach ist es nicht. Ich hatte vielleicht vergessen zu erwähnen, dass die Zeilennummer der Compiler-Fehlermeldung auf den Anwendercode - also die Zeile 'x.Access(..)=..;' zeigt. Außerdem kann der Compiler nicht auf H1_AddOn.h verweisen, da diese Datei nicht am Build-Prozess teilnimmt! Das ist ja die Problematik!

Wenn der Compiler wenigstens auf die Methode Access() in H1.h zeigen würde, dann hätte ich dort den passenden Kommentar längst hingeschrieben. Das würde mir schon reichen, wenn man den Code irgendwie dahingehend ändern könnte.

Aber vielleicht hat jemand eine Idee für eine ganz andere Konstruktion. Das Ziel ist immer diese Zuweisung 'x.Access(..)=..;' oder etwas vergleichbares für den Anwender zu realisieren. Wobei rechts ein mehr oder weniger beliebiger Typ stehen kann; deshalb das Template und deshalb steht der Code auch in H1_AddOn.h und deshalb soll den ja auch nicht jeder überall inkludieren, obwohl er nur an wenigen Stellen benötigt wird.

Gruß
Werner

volkard

Der Holger wird doch in der ersten Suchminute die Datei finden, die die Klasse Reference anbietet, um nachzuschauen, was an deren operator= auf einmal nicht stimmt. Oder?
Ansonsten auf Shade hören.

volkard

namespace OnError_C2582_operator_assign_function_is_unavailable_in_Reference_please_include_H1_Addon_h{
class Reference; // nur forward!
}
using OnError_C2582_operator_assign_function_is_unavailable_in_Reference_please_include_H1_Addon_h::Reference;

class Universal // wird sehr häufig benötigt
{
public:
    // .. viele Methoden usw.
    Reference Access( int idx ); // Zuweisungs-Wrapper (s.u.) wird selten benötigt
};

int main()
{
    Universal x;
    x.Access(42) = 1;
}

ergibt die Fehlermeldung

p:\xx\yy\main.cpp(16) : error C2582: Die Funktion 'operator =' ist in 'OnError_C2582_operator_assign_function_is_unavailable_in_Reference_please_include_H1_Addon_h::Reference' nicht verfügbar

Ich bin's irgendwie gewohnt, daß die Universal in der Universal.hpp und die Reference in der Reference.hpp steckt. Statt H1.hpp und H1_Addon.hpp. Vielleicht würde auch das die Suche ausreichend beschleunigen.

Werner Salomon

Hee danke!
volkard das ist so einfach wie genial

gibt's noch mehr Möglichkeiten?

Werner Salomon

volkard schrieb:

Ich bin's irgendwie gewohnt, daß die Universal in der Universal.hpp und die Reference in der Reference.hpp steckt. Statt H1.hpp und H1_Addon.hpp. Vielleicht würde auch das die Suche ausreichend beschleunigen.

.. das ist auch so. Ich hatte die Namen hier nur für das Posting geändert, um das wesentliche darzustellen.

volkard

Proxies halt.

class Reference; // nur forward!

/*class Reference 
{ 
public: 
    template< typename T > 
    Reference& operator=( const T& data ) 
    { 
        // .. Code - spielt hier keine Rolle 
        return *this; 
    } 
};*/

class RefProxy
{
	Reference& ref;
public:
	RefProxy(Reference& r)
		:ref(r)
	{
	}
	template< typename T > 
    RefProxy& operator=( const T& data ) 
    { 
		//Bei error C2582: Die Funktion 'operator =' ist in 'Reference' nicht verfügbar
		//ist Reference nicht inkludiert worden!
        ref=data;//Jetzt kommt nämlich hier der Fehler.
        return *this; 
    } 

};

class Universal // wird sehr häufig benötigt
{
public:
    // .. viele Methoden usw.
    RefProxy Access( int idx ); // Zuweisungs-Wrapper (s.u.) wird selten benötigt
};

int main()
{
    Universal x;
    x.Access(42) = 1;
}

Aber das paßt inhaltlich eventuell nicht, weil Reference anscheinend selber schon ein Proxy ist. Es sollte Reference immer inkludiert werde und Reference kann ihre Implementierung verstecken.

Werner Salomon

volkard schrieb:

Proxies halt.

Nein - wie Du schon vermutest hast, übersetzt das nicht. Die implizite Konvertierung von Reference nach RefProxy wird vom Compiler nicht gemacht.
Ich hatte das schon probiert.

Gruß
Werner

volkard

Welche implizite Konvertierung?

Werner Salomon

volkard schrieb:

Welche implizite Konvertierung?

.. ich habe mich vertan. Bei mir lieferte Access immer noch Reference statt RefProxy zurück. Und ich hatte auch nicht die Zuweisung in RefProxy.
Doch so sollte es gehen.

Danke & Gruß
Werner