none
static class in c++ with operator overloading?? IS POSSIBLE ?? RRS feed

  • Question

  • I made following class to interact with console in c++.

    //----------------------------------------------------------
    static class console {
        // HMODULE hKernel32 = LoadLibraryA("kernel32.dll");
        // string yy=GetCommandLineA();
        //  _SYSTEMTIME SYSTEMTIME;
        // GetSystemTime(&SYSTEMTIME);
        // Sleep(88);
        // GetSystemDirectoryA(ppp, 99);
    private:
        HANDLE stdOutput;
        HANDLE stdInput;
        HWND consoleWindow;
        bool InitFlag = 0;
        void CheckInit() {
            if (InitFlag)return;
            AllocConsole();
            SetConsoleTitle(_T("DOSBox Debugger"));
            consoleWindow = GetConsoleWindow();
            stdOutput = GetStdHandle(STD_OUTPUT_HANDLE);
            stdInput = GetStdHandle(STD_INPUT_HANDLE);
            DWORD lpMode;
            GetConsoleMode(stdInput, &lpMode);
            SetConsoleMode(stdInput, lpMode | ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT | ENABLE_QUICK_EDIT_MODE);
            SetCursorVisible();
            InitFlag = 1;
        }
    
        DWORD const_chrs_length(const char* pConstChars) {
            DWORD strLength = 0;
            while (pConstChars[strLength] != 0)strLength++;
            return strLength;
        }
    
        void WriteConstChars(const char* doWypisania) {
            CheckInit();
            DWORD rozmiar = const_chrs_length(doWypisania);
            WriteConsoleA(stdOutput, doWypisania, rozmiar, NULL, NULL);
        }
    
        void WriteString(string& doWypisania) {
            CheckInit();
            WriteConsoleA(stdOutput, (char*)doWypisania, doWypisania.len(), NULL, NULL);
        }
    
        void WriteChar(char& myChar) {
            CheckInit();
            string myString(1);
            myString[0] = myChar;
            WriteConsoleA(stdOutput, (char*)myString, myString.len(), NULL, NULL);
        }
    
        string ReadString() {
            CheckInit();
            string toBeRead(255);
            DWORD howManyRead = 0;
            BOOL what = ReadConsoleA(stdInput, (char*)toBeRead, 254, &howManyRead, 0);
            toBeRead[howManyRead - 2] = 0;
            return toBeRead;
        }
    
        void WriteInt(int& paramInt) {
            CheckInit();
            int tmpInt = paramInt;
            char signFlag = 0;
            if (tmpInt < 0) {
                signFlag = 1;
                tmpInt = -tmpInt;
            }
            const int maxString = 13;
            string myString(maxString);
            int index = maxString - 2;
            do {
                char reminder = (char)(tmpInt % 10 + 0x30);
                tmpInt = tmpInt / 10;
                myString[index] = reminder;
                index--;
            } while (tmpInt > 0);
            if (signFlag > 0) {
                myString[index] = '-';
            }
            else {
                myString[index] = '+';
            }
            for (int i = 0;i < maxString-index-1;i++)WriteChar(myString[i+index]);
        }
    
        WORD ReadVirtualKeyCode() {
            CheckInit();
            WORD VirtualKeyCode = 0;
            DWORD numEventsAvailable;
            while (GetNumberOfConsoleInputEvents(stdInput, &numEventsAvailable) == TRUE && numEventsAvailable > 0) {
                INPUT_RECORD input_record;
                DWORD events = 0;
                ReadConsoleInput(stdInput, &input_record, 1, &events);
                if (input_record.EventType == KEY_EVENT && input_record.Event.KeyEvent.bKeyDown) {
                    VirtualKeyCode = input_record.Event.KeyEvent.wVirtualKeyCode;
                }
            }
            return VirtualKeyCode;
        }
    
        void SetCursorVisible() {
            CONSOLE_CURSOR_INFO cci;
            cci.dwSize = 10;
            cci.bVisible = TRUE;
            SetConsoleCursorInfo(GetStdHandle(STD_OUTPUT_HANDLE), &cci);
        }
    
        friend console& operator<<(console& paramConsole, const char* paramChars);
        friend console& operator<<(console& paramConsole, string& paramString);
        friend console& operator>>(console& paramConsole, string& paramString);
        friend console& operator<<(console& paramConsole, int& paramInt);
        friend console& operator>>(console& paramConsole, int& paramInt);
        friend console& operator<<(console& paramConsole, WORD& paramWord);
        friend console& operator>>(console& paramConsole, WORD& paramWord);
    public:
    
        int GetMAXx() {
            CheckInit();
            CONSOLE_SCREEN_BUFFER_INFO bufInfo;
            GetConsoleScreenBufferInfo(stdOutput, &bufInfo);
            return bufInfo.dwSize.X;
        }
        int GetMAXy() {
            CheckInit();
            CONSOLE_SCREEN_BUFFER_INFO bufInfo;
            GetConsoleScreenBufferInfo(stdOutput, &bufInfo);
            return bufInfo.dwSize.Y;
        }
        void gotoXY(int x, int y) {
            CheckInit();
            COORD c;
            c.X = x;
            c.Y = y;
            SetConsoleCursorPosition(stdOutput, c);
        }
        int GetTextColor() {
            CheckInit();
            CONSOLE_SCREEN_BUFFER_INFO bufInfo;
            GetConsoleScreenBufferInfo(stdOutput, &bufInfo);
            return bufInfo.wAttributes;
        }
        void SetTextColor(int wAttributes) {//Bits 0-3 are the foreground color, and bits 4 - 7 are the background color.
            CheckInit();
            SetConsoleTextAttribute(stdOutput, wAttributes);
        }
        void ClrScr() {
            CheckInit();
            CONSOLE_SCREEN_BUFFER_INFO bufInfo;
            GetConsoleScreenBufferInfo(stdOutput, &bufInfo);
            int lineLength = bufInfo.dwSize.X;
            int columnLength = bufInfo.dwSize.Y;
            short textAttribute = bufInfo.wAttributes;
            string _oneLineSpace(lineLength);
            for (int i = 0;i < lineLength;i++)_oneLineSpace[i] = ' ';
            WORD* _oneLineAttributes = new WORD[lineLength];
            for (int i = 0;i < lineLength;i++)_oneLineAttributes[i] = textAttribute;
            COORD dwWriteCoord = { 0,0 };
            DWORD numWritten;
            WORD attribute = 0x07;
            for (int i = 0;i < columnLength;i++) {
                dwWriteCoord.Y = i;
                WriteConsoleOutputAttribute(stdOutput, _oneLineAttributes, lineLength, dwWriteCoord, &numWritten);
                WriteConsoleOutputCharacterA(stdOutput, _oneLineSpace, lineLength, dwWriteCoord, &numWritten);
            }
            gotoXY(0, 0);
        }
        void Free() {
            FreeConsole();
            InitFlag = 0;
        }
    };
    console& operator<<(console& paramConsole, const char* paramChars)
    {
        string tempString = paramChars;
        paramConsole.WriteString(tempString);
        return paramConsole;
    }
    console& operator<<(console& paramConsole, string& paramString)
    {
        paramConsole.WriteString(paramString);
        return paramConsole;
    }
    console& operator>>(console& paramConsole, string& paramString)
    {
        paramString = paramConsole.ReadString();
        return paramConsole;
    }
    console& operator<<(console& paramConsole, int& paramInt)
    {
        paramConsole.WriteInt(paramInt);
        return paramConsole;
    }
    console& operator>>(console& paramConsole, int& paramInt)
    {
        string tempString = paramConsole.ReadString();
        paramInt = 0;
        int index = 0;
        char sign = 1;
        if (tempString[0] == '+') {
            index++;
        }
        else if (tempString[0] == '-') {
            sign = -1;
            index++;
        }
        else if (tempString[0] == '0' && (tempString[1] == 'x' || tempString[1] == 'X')) {
            index += 2;
            while ((tempString[index] >= '0' && tempString[index] <= '9') || (tempString[index] >= 'a' && tempString[index] <= 'f') || (tempString[index] >= 'A' && tempString[index] <= 'F')) {
                if (tempString[index] >= 'a' && tempString[index] <= 'f') {
                    tempString[index] &= 0b11011111;//na duże
                }
                if (tempString[index] >= 'A' && tempString[index] <= 'F') {
                    tempString[index] = tempString[index] - 'A' + 10;
                }
                else {
                    tempString[index] -= '0';
                }
                paramInt *= 16;
                paramInt += tempString[index];
                index++;
            }
            return paramConsole;
        }
        while (tempString[index] >= '0' && tempString[index] <= '9') {
            tempString[index] &= 0xF;
            paramInt *= 10;
            paramInt += tempString[index];
            index++;
        }
        paramInt *= sign;
        return paramConsole;
    }
    console& operator<<(console& paramConsole, WORD& paramWord)
    {
        int ileWypisać = paramWord;
        paramConsole.WriteInt(ileWypisać);
        return paramConsole;
    }
    console& operator>>(console& paramConsole, WORD& paramWord)
    {
        paramWord = paramConsole.ReadVirtualKeyCode();
        return paramConsole;
    }
    console cons;
    //----------------------------------------------------------

    I also use written by me class for string:

    //----------------------------------------------------------
    class string {
        char* _string = nullptr;
    
    public:
    
        string() {    }
    
        string(int length) { 
            _string = new char[length+1];
            _string[length] = 0;
        }
    
        string(const char* newChars)
        {
            size_t nChars = strlen(newChars) + 1;
            _string = new char[nChars];
            strcpy_s(_string, nChars, newChars);
        }
    
        string(string& rhs)
        {
            if (_string) delete[] _string;
            size_t nChars = strlen(rhs._string) + 1;
            _string = new char[nChars];
            strcpy_s(_string, nChars, rhs._string);
        }
    
        string(string&& rhs)
        {
            if (_string) delete[] _string;
            _string = rhs._string;
            rhs._string = nullptr;
        }
    
        string& operator=(char* rhs)
        {
            _string=rhs;
            return *this;
        }
    
        string& operator=(string& rhs)
        {
            if (_string) delete[] _string;
            size_t nChars = strlen(rhs._string) + 1;
            _string = new char[nChars];
            strcpy_s(_string, nChars, rhs._string);
            return *this;
        }
    
        string& operator=(string&& rhs)
        {
            if (_string) delete[] _string;
            _string = rhs._string;
            rhs._string = nullptr;
            return *this;
        }
    
        ~string() {
            if (_string) delete[] _string;
        }
    
        char& operator[](int index)
        {
            return _string[index];
        }
    
        operator char*& () { return _string; }
    
        DWORD len() {
            DWORD strLength = 0;
            while (_string[strLength] != 0)strLength++;
            return strLength;
        }
    };
    
    //----------------------------------------------------------

    QUESTION IS HOW TO MAKE THAT CLASS STATIC?

    There is variable cons under console class. I use this in following way:

    string myString="this is my string";

    cons<<myString>>myString<<myString;

    QUESTION IS:  WOULD I MAKE console CLASS STATIC so I would not have to use cons variable BUT

    MAKE console<<myString>>myString<<myString;

    ?????????

    Saturday, November 21, 2020 7:11 PM

All replies

  • Maybe rename console to Console (try Refactor feature of Visual Studio), remove cons variable, and make this change:

    static class Console

    {

       . . .

    } console;


    Also check if string class, written by you, includes the recommendations: https://docs.microsoft.com/answers/answers/170658/view.html.



    • Edited by Viorel_MVP Saturday, November 21, 2020 8:21 PM
    Saturday, November 21, 2020 8:16 PM
  • I made following class to interact with console in c++.

    Note that this forum is for issues related to the C# (C Sharp) language, not C++.

    The C++ forum(s) on MSDN have been archived (closed except for browsing), and
    new C++ issues should be posted in the Q&A forums (with the C++ "tag").

    https://docs.microsoft.com/en-us/answers/topics/c++.html

    Note also that this C# forum will also be closing soon, and new C# issues
    need to move to Q&A also.

    - Wayne

    Saturday, November 21, 2020 10:56 PM