VC++ 2022 Zu viele Affen im System !



  • Dieses Microsoft VisualStudio 2022 ist so genial aber es kommen Dinger vor die dürfen einfach wahr nicht sein.
    Ich definiere eine Klasse die überhaupt auf gar keine Hardware zugreift, in einem Desktop_Assistenten oder
    einer Applikation mit graphischer Benutzeroberfläche.

    Die Definition compiliert er noch. Aber sobald ich drauf zugreife und das Klassenobjekt lokal in einem switch-
    case einer Funktion definiere um es direkt benutzen zu können, ist es aus, da kommt der
    Fehler mit irgendeinem intellisense Erkenner-Mist. E2928 PCH Warnung Unbekannter Fehler es wurde
    keine Intellisense PCH Datei generiert.

    Ist sowas Vorsatz ?



  • Hier meine Klasse:

    //_____________________________________________________________________________
    class VisualC16 //::::C16__VISUALISIERUNGSKLASSE::::_________
    {
    public:
    //-------------// Ausgabeinterface, mitlaufende Variablen --------------
    int VAL; // Code gelesenen Quadrantens. 0-15 Pixelwert, 16 geteilt.
    int X; // X-Koordinate mitlaufend geht von links nach rechts.
    int Y; // Y-Koordinate mitlaufend geht von oben nach unten.
    int Depth; // Verschachtelungstiefe 0 positiv.
    int Offset; // Eine Zweierpotenz von 1 !! Ist die Bildgröße.
    int Qx; // Fortschreitender Qudrantensektionen-Abzählindex.
    //-------------//--------------------------------------------------------
    bool* InP; // Dateninput, mitlaufender Lesezeiger.
    int* Stack; // Stapelzeiger der rekursiven Abarbeitung.
    // Enthält Auftragscodes.
    // 0: Abbruch, Lesung zuende.
    // 1: Lese einen neuen Quadranten.
    // 2: Lese zwei neue Quadranten.
    // 3: Lese drei neue Quadranten.
    // 4: Lese vier neue Quadranten.
    //
    // Konstruktor startet eine serielle Durchlesung vom Hauptanfang..............
    VisualC16(bool* inp, int* stack, int offset, int x, int y)// Vom Hauptanfang.
    {
    InP = inp;
    Stack = stack;
    Offset = offset;
    X = x;
    Y = y;
    VAL = 17;
    Qx = 0;
    Depth = 0;
    *Stack = 0; // Ausstiegscode einschreiben.
    Stack++;
    *Stack = 1; // Schreibe den Befehlscode ein: Ein Quadrat lesen.
    X += Offset; // Einsprung-Medizin in rekursive Routine.
    }; //_________//____________________________________________________________
    //_________// Initialisieren und einmal treiben für eine serielle Durchlesung
    //_________// der Codematrix, die abfragbare Pixelkoordinaten X, Y mitzieht.
    //_________// Und den VAL Quadrantencode abrufbar macht, den der
    //_________// schnelle Treiberprogrammierer auf leichsteste Weise mit
    //_________// einer 17-Farben-Tabelle und eine Funktion zur Zeichnung
    //_________// bunter Quadrate auf jede Graphikoberfläche zaubern kann.

    //_______________________// Triggert die Rechenschritte, die wird getrieben.
    bool Progress();      // Rückgabe wahr:    Die Lesung läuft.
    

    //-----------------------// Rückgabe falsch: Die Lesung ist zuende.
    // Treiben geht wirklich einfach :
    //
    // VisualC16 Reader( Datenfutter );
    // while ( Reader.Progress() )
    // {
    // // VAL, X, Y, etc. lesen und buntes Quadrat zeichnen lassen.
    // };

    };

    //===================================================================//
    bool VisualC16::Progress() //
    { //================================================================//
    int Command = *Stack;
    switch ( Command )
    {
    case 0: default: return false;
    //------------------------------------// Koordinaten linksoben.
    case 4: X += Offset; // Vier Teilungsquadrate zeichnen.
    Y += Offset; // rechte untere Ecke.
    *Stack = 3; break; //
    //-------------------------------------//
    case 3: X -= Offset; // linke untere Ecke.
    *Stack = 2; break; //
    //-------------------------------------//
    case 2: Y -= Offset; //
    X += Offset; // rechte obere Ecke.
    *Stack = 1; break; //
    //-------------------------------------//
    case 1: X -= Offset; // Zurück zum Ursprung.
    //////////////////////////////////////// Links oben.

        bool TB0 = *InP; InP++;  // TB0 = Erstes Entscheidungsbit. 
        if (TB0) // ------------- Unterteilt oder Adresse ?
        {
            bool TB1 = *InP; InP++;
            if (TB1) // ---- Jetzt kommt die lange Binärzahl.
            {
                return false; // Nicht implementiert, Prozessabbruch.
            }
            else       // ------------- Es folgen vier Quadranten.
            {
                Depth++;           // Jetzt geht die Verschachtelung tiefer runter.
                Stack++;           // Und der Stack naturgemäß rauf !
                *Stack = 4;           // Befehl zum Zeichnen von vier Subquadranten.
                Offset = Offset / 2;
                VAL = 16;          // Code für unterteilten Quadranten.
                return  true;
            };
        }
        else   //-----------------------------// Elementarer Quadrant.
        {
            VAL = 0;              //
            if (*InP) { VAL |= 1; }; InP++;    // Immittiert ein bischen das serielle
            if (*InP) { VAL |= 2; }; InP++;    // Bitschlangeninterface.
            if (*InP) { VAL |= 4; }; InP++;    // Eingabedaten raus saugen.
            if (*InP) { VAL |= 8; }; InP++;    // 4 Bits Pixelfarbcode.
    
            if (Depth == 0)                  // Raus hier, Job erledigt,
            {
                *Stack = 0;            // extra Für ein einzelnes Pixel.
            }
            else // Das kleinere Pixel befindet sich in tieferer Verschachtelung.
            {
                if (Command == 1)
                {
                    Depth--;
                    Stack--;
                    Offset = Offset * 2;
                }
            };
            return true;
        };
    };

Log in to reply