Operatorenüberladung

Parapiler

und was hat der ofstream da zu suchen?! warum nutzt man den?!

volkard

Original erstellt von Parapiler:
sorry, ich habe von dem ganzen natürlich wieder mal keinen plan kannst das vielleicht mal erläutern? was willst du prüfen? muss man das was du prüfen willst immer prüfen?!

man vergißt gerne mal, ein delete aufzurufen. oder manchmal ruft man eins zu viel auf. mit desem überladenen operator new/delete könnte man sich alle (nicht ganz alle) aufrufe von new/delete mitloggen lassen, und wenn man den verdacht hat. daß was nicht stimmt, das logfile auswerten.
nur mal so als beispiel, daß du was konkretes in der hand hast auf deine frage "wie würde das denn aussehen?!". man muß das aber nicht so prüfen. da gibts viel bessere sachen.

Parapiler

also mal ganz konkret: in einem Programm von mir wird eine Exception ausgelöst und niemand findet einen Fehler, ich dachte, eventuell kann man mittels Exceptionhandling und Operatorüberladung von new den Speicher kontrollieren und so leichter den Fehler finden. Der Fehlerhafte Code ist dieser hier:

int bytecounter = 0;
        char* recbyte =  NULL;
        unsigned long* bytes = new unsigned long [];
        *bytes = 0;

        //warten, bis daten am Socket anliegen
        while (*bytes == 0)
        {

            //Anzahl der wartendem Bytes bestimmen und Speicher reservieren
            rc = ioctlsocket (daMember[counter].Socket, FIONREAD, bytes);

            if (rc != 0)
            {
                int n = WSAGetLastError ();

                switch (n)
                {
                    case WSANOTINITIALISED:
                        cout << "Fehler: Socket ist nicht initialisiert" << endl;
                        return SOCKET_ERROR;
                    case WSAENETDOWN:
                        cout << "Fehler: Das Netzwerksystem hat versagt" << endl;
                        return SOCKET_ERROR;
                    case WSAEINPROGRESS:
                        cout << "Fehler: Ein blockierender Prozess ist im Vorgang" << endl;
                        return SOCKET_ERROR;
                    case WSAENOTSOCK:
                        cout << "Fehler: Der Descriptor ist kein Socket." << endl;
                        return SOCKET_ERROR;
                    case WSAEFAULT:
                        cout << "Fehler: Der Pointer zeigt auf einen ungültigen Adressenbereich" << endl;
                        return SOCKET_ERROR;

                }

            }

            if (*bytes != 0)
            {

                cout << "Daten liegen vor" << endl;
                break;
            }
        }

        bytecounter = *bytes;
        recbyte = new char [bytecounter];

        //Struktur auslesen
        int n = recv (daMember[counter].Socket, recbyte, bytecounter, 0);

        if (n == 0)
        {
            cout << "Empfangen fehlgeschlagen" << endl;
            return SOCKET_ERROR;

        }

        if (n == -1)
        {
            cout << "Empfangen fehlgeschlagen" << endl;
            return SOCKET_ERROR;
        }

        cout << recbyte << endl;

        //UI- Struktur füllen
        memset (&userinformation, 0, sizeof (UI));

        //erstes Byte (BOOLEAN) des Empfangsbuffers in registry kopieren
        memcpy (&userinformation[counter].registry, recbyte + sizeof (int) , sizeof (bool));

        //für den Fall eines Gastzuganges
        if (userinformation[counter].registry == false)
        {

            //Speicher für den char* reservieren (Nicknamen)
            userinformation[counter].nickname = new char [100];
            //Nicknamen rauskopieren
            memcpy (&userinformation[counter].nickname, recbyte + sizeof (int) + sizeof (bool), bytecounter- sizeof(bool)-sizeof (int));
            //userinformation[counter].nickname = "hallo";
            cout << &userinformation[counter].nickname << endl;
            cout << userinformation[counter].nickname << endl;
            daMember[counter].myuser = new char [bytecounter];
            memcpy (&daMember[counter].myuser, userinformation[counter].nickname, bytecounter - sizeof (bool));

        }

volkard

unsigned long* bytes = new unsigned long [];

bereits hier kann ich nicht folgen.

Parapiler

naja dort wird eben nur für einen long Speicher reserviert, ist doch ganz normal:

ausführlich

unsigned long bytes* = NULL;
bytes = new unsigned long [1];

volkard

Original erstellt von Parapiler:
also mal ganz konkret: in einem Programm von mir wird eine Exception ausgelöst und niemand findet einen Fehler

welche exception?

Parapiler

beim zweiten cout und dem letzten memcpy wird eine Access violation ausgelöst (letzte und drittletzte zeile) und suche nun nach Hinweisen. Allerdings finde ich keine. Der Speicher ist reserviert, die pointer sind gültig.... ich habe da keine ahnung mehr.... ich dachte eventuell könnte man so ein Abbild von Speicher usw. bekommen und so auf einen Hinweis stoßen, schrittweises durchgehen des Codes ist ja gescheitert (nicht nur bei mir sondern auch bei anderen die ich mal nachgucken haben lasse, niemand hat was gefunden).

Eventuell etwas zur Vorgeschichte:

Der Code empfängt einen Buffer von einem Socket. Über das Socket wird eine in einem Buffer serialisierte (mit memcpy hintereinanderkopierte) Struktur. Diese Struktur soll nun wieder entfriemelt werden.

volkard

Original erstellt von Parapiler:
beim zweiten cout und dem letzten memcpy wird eine Access violation ausgelöst

falls du zufällig den msvc benutzt, starte im debug-modus mit f5 und du wirst in den debugger geworfen und dann drück alt+f7 für das fenster mit den bisherigen funktionsaufrufen und schau, ob in den variablen immer das richtige drinsteht und so fängte die ursache einer schutzverletzung normalerweise in wenigen minuten.
mehr kann ich leider nicht helfen.

Parapiler

ja das mache ich schon seit wochen....gibt es kein besseres konzept? Das nützt nämlich alles nicht ich kann damit nix weiter anfangen

volkard

Original erstellt von Parapiler:
ja das mache ich schon seit wochen....gibt es kein besseres konzept? Das nützt nämlich alles nicht ich kann damit nix weiter anfangen

wenns keiner geheimhaltung unterliegt, kann ichs probieren.

Parapiler

ne du kannst die Projektdateien gerne haben. Rede mich einfach an, dann schicke ich sie dir....

AIM: PaRaDoXoNtWeNtY
ICQ: 157413201
Yahoo: Parapiler

volkard

volkard@normannia.de

volkard

richtig ist

memcpy (userinformation[counter].nickname, recbyte + sizeof (int) + sizeof (bool), bytecounter- sizeof(bool)-sizeof (int));

willst ja dem memcpy den wert von userinformation[counter].nickname geben, also die adresse den gerade neu angelegten speichers.

fasch ist

memcpy (&userinformation[counter].nickname, recbyte + sizeof (int) + sizeof (bool), bytecounter- sizeof(bool)-sizeof (int));

denn du willst den usernamen nicht nehmen und da reinschreiben, wo sich eigentlich die adresse des neuen speichers gemerkt werden soll.

volkard

Original erstellt von Parapiler:
schrittweises durchgehen des Codes ist ja gescheitert (nicht nur bei mir sondern auch bei anderen die ich mal nachgucken haben lasse, niemand hat was gefunden).

durchgehen und sich die variableninhalte angucken.
also hier recbyte. ins watchfenster hab ich mir gelegt
recbyte[0]
recbyte[1]
recbyte[2]
recbyte[3]
recbyte[4]
recbyte[5]
recbyte[6]
und siehe da, in 5 und 6 waren die ersten buchstaben des namens. und dann war ja eigentlich schon die zeile mit dem memcpy als bösewicht identifiziert. nach dem memcpy war nämlich an ziel nix gescheites drin, aer in der quelle stehen ordentliche daten.
und dann hilt nur noch so lange draufstarren, bis man sich frage, ob das & dort absicht ist.

Parapiler

danke das war der Fehler wirklich tausend dankeschön! Ich habe das bei dem darauffolgenden memcpy auch korrigiert, und das funktioniert nun.

Jedoch, auch wenn das jetzt leicht der falsche Thread ist, aber beim ersten memcpy:

//erstes Byte (BOOLEAN) des Empfangsbuffers in registry kopieren
        memcpy (&userinformation[counter].registry, recbyte + sizeof (int) , sizeof (bool));

gibt der mir einen fehler, wenn ich als ersten Parameter die Adresse nicht mehr angebe. Das wird ja auch richtig ausgewertet, aber ich verstehe jetzt nicht mehr warum.

volkard

hab deinen code schon gelöscht.
aber ist .registry vielleicht ein char-array? dann wär die adresse des ersten elements in der tat &userinformation[counter].registry. und wenns ein char-zeiger wäe, der wo anders hinzeigt, dann wäre die andresse des ersten elements der woandersdaten userinformation[counter].registry.

Parapiler

nein ist nen bool aber das andere war nen char-array..... dann ist es eben genau andersrum als du gesagt hast, danke.

volkard

Original erstellt von Parapiler:
nein ist nen bool aber das andere war nen char-array..... dann ist es eben genau andersrum als du gesagt hast, danke.

éin char-array wäre wie ein bool. aber ein char-pointer wäre anders.

Parapiler

Aber zurück zum Threadthema: die Operatorenüberladung. Wie ist denn der Zusammenhang von der Operatorenüberladung zu den Streamklassen (ostream os) ???????????

volkard

Original erstellt von Parapiler:
Aber zurück zum Threadthema: die Operatorenüberladung. Wie ist denn der Zusammenhang von der Operatorenüberladung zu den Streamklassen (ostream os) ???????????

keiner.
außer, daß << ein operator ist, den man zum ausgeben überlaen kann,
und new auch ein operator ist, den man überladen kann, wenn man sich langweilt.