.

class x {
     public :
     void y();
};

void x::y()
{
int n;
      start:
      cout<<"input number:";  
      cin>>n;
      if (n%2==0){
         cout<<"<warning>, input number must odd\n";
         sleep(2);
         clrscr();
           goto start;
      }
}

void main (){
x run;
     cout<<"\ntest number :\n";
     cout<<"\n===================\n";
     run.y();
getch();
}
.

.
void x::y()
{
int n;
      do{
      cout<<"input number:";  
      cin>>n;
           if (n%2==0){
              cout<<"<warning>, input number must odd\n";
              sleep(2);
              clrscr();
              cout<<"\ntest number :";
              cout<<"\n===================\n";
           }
      }while(n%2==0);
      cout<<"your input odd number is :"<<n;
}
.

void ClearConsoleFrom(int row)
{
    //Get the handle to the current output buffer...
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     //This is used to reset the carat/cursor to the top left.
     COORD coord = {0, row};
     //A return value... indicating how many chars were written
     //   not used but we need to capture this since it will be
     //   written anyway (passing NULL causes an access violation).
     DWORD count;
     //This is a structure containing all of the console info
     // it is used here to find the size of the console.
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     //Here we will set the current color
     if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
     {
          //This fills the buffer with a given character (in this case 32=space).
          FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * (csbi.dwSize.Y - row), coord, &count);
          FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * (csbi.dwSize.Y - row), coord, &count );
          //This will set our cursor position for the next print statement.
          SetConsoleCursorPosition(hStdOut, coord);
     }
     return;
}

#include <windows.h>
#include <stdio.h>
#include <iostream>

using namespace std;


void ConPrint(char *CharBuffer, int len);
void ConPrintAt(int x, int y, char *CharBuffer, int len);
void gotoXY(int x, int y);
void ClearConsole();
void ClearConsoleFrom(int row);
void ClearConsole(int ForgC, int BackC);
void SetColor(int ForgC, int BackC);
void SetColor(int ForgC);
void HideCursor();
void ShowCursor();

class x {
     public :
     void y();
};

void x::y()
{
    int n;
start:
    gotoXY(0,4);
    cout<<"input number:";  
    cin>>n;
    if (n%2==0){
    cout<<"<warning>, input number must odd\n";
    Sleep(2000);
    ClearConsoleFrom(4);
    goto start;
    }

}

void main (){
    x run;
    ClearConsole(15, 1);
    cout<<"\ntest number :\n";
    cout<<"\n===================\n";
    run.y();
    cin.get();
}




//This will clear the console while setting the forground and
//  background colors.
void ClearConsole(int ForgC, int BackC)
{
     WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);
     //Get the handle to the current output buffer...
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     //This is used to reset the carat/cursor to the top left.
     COORD coord = {0, 0};
     //A return value... indicating how many chars were written
     //   not used but we need to capture this since it will be
     //   written anyway (passing NULL causes an access violation).
     DWORD count;

     //This is a structure containing all of the console info
     // it is used here to find the size of the console.
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     //Here we will set the current color
     SetConsoleTextAttribute(hStdOut, wColor);
     if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
     {
          //This fills the buffer with a given character (in this case 32=space).
          FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);
          
          FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count );
          //This will set our cursor position for the next print statement.
          SetConsoleCursorPosition(hStdOut, coord);
     }
     return;
}

//This will clear the console.
void ClearConsole()
{
     //Get the handle to the current output buffer...
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     //This is used to reset the carat/cursor to the top left.
     COORD coord = {0, 0};
     //A return value... indicating how many chars were written
     //   not used but we need to capture this since it will be
     //   written anyway (passing NULL causes an access violation).
     DWORD count;
     //This is a structure containing all of the console info
     // it is used here to find the size of the console.
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     //Here we will set the current color
     if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
     {
          //This fills the buffer with a given character (in this case 32=space).
          FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * csbi.dwSize.Y, coord, &count);
          FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count );
          //This will set our cursor position for the next print statement.
          SetConsoleCursorPosition(hStdOut, coord);
     }
     return;
}

void ClearConsoleFrom(int row)
{
    //Get the handle to the current output buffer...
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     //This is used to reset the carat/cursor to the top left.
     COORD coord = {0, row};
     //A return value... indicating how many chars were written
     //   not used but we need to capture this since it will be
     //   written anyway (passing NULL causes an access violation).
     DWORD count;
     //This is a structure containing all of the console info
     // it is used here to find the size of the console.
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     //Here we will set the current color
     if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
     {
          //This fills the buffer with a given character (in this case 32=space).
          FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * (csbi.dwSize.Y - row), coord, &count);
          FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * csbi.dwSize.Y, coord, &count );
          //This will set our cursor position for the next print statement.
          SetConsoleCursorPosition(hStdOut, coord);
     }
     return;
}


//This will set the position of the cursor
void gotoXY(int x, int y)
{
     //Initialize the coordinates
     COORD coord = {x, y};
     //Set the position
     SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord);
     return;
}

//This will set the forground color for printing in a console window.
void SetColor(int ForgC)
{
     WORD wColor;
     //We will need this handle to get the current background attribute
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     CONSOLE_SCREEN_BUFFER_INFO csbi;
    
     //We use csbi for the wAttributes word.
     if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
     {
        //Mask out all but the background attribute, and add in the forgournd color
          wColor = (csbi.wAttributes & 0xF0) + (ForgC & 0x0F);
          SetConsoleTextAttribute(hStdOut, wColor);    
     }
     return;
}

//This will set the forground and background color for printing in a console window.
void SetColor(int ForgC, int BackC)
{
     WORD wColor = ((BackC & 0x0F) << 4) + (ForgC & 0x0F);;
     SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), wColor);    
     return;
}

//Direct console output
void ConPrint(char *CharBuffer, int len)
{
    DWORD count;
     WriteConsole(GetStdHandle(STD_OUTPUT_HANDLE), CharBuffer, len, &count, NULL);
     return;
}

//Direct Console output at a particular coordinate.
void ConPrintAt(int x, int y, char *CharBuffer, int len)
{
    DWORD count;
     COORD coord = {x, y};
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleCursorPosition(hStdOut, coord);
     WriteConsole(hStdOut, CharBuffer, len, &count, NULL);
     return;
}

//Hides the console cursor
void HideCursor()
{
     CONSOLE_CURSOR_INFO cciCursor;
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
    
     if(GetConsoleCursorInfo(hStdOut, &cciCursor))
     {
          cciCursor.bVisible=FALSE;
     }
     return;
}

//Shows the console cursor
void ShowCursor()
{
     CONSOLE_CURSOR_INFO cciCursor;
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
    
    
     if(GetConsoleCursorInfo(hStdOut, &cciCursor))
     {
          cciCursor.bVisible=TRUE;
     }
     return;
}

void ClearRows(int row1, int row2)
{
    //Get the handle to the current output buffer...
     HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
     //This is used to reset the carat/cursor to the top left.
     COORD coord = {0, row};
     //A return value... indicating how many chars were written
     //   not used but we need to capture this since it will be
     //   written anyway (passing NULL causes an access violation).
     DWORD count;
     //This is a structure containing all of the console info
     // it is used here to find the size of the console.
     CONSOLE_SCREEN_BUFFER_INFO csbi;
     //Here we will set the current color
     if(GetConsoleScreenBufferInfo(hStdOut, &csbi))
     {
          //This fills the buffer with a given character (in this case 32=space).
          FillConsoleOutputCharacter(hStdOut, (TCHAR) 32, csbi.dwSize.X * (row2-row1), coord, &count);
          //This sets the forground/background color
          FillConsoleOutputAttribute(hStdOut, csbi.wAttributes, csbi.dwSize.X * (row2-row1), coord, &count );
          //This will set our cursor position for the next print statement.
          SetConsoleCursorPosition(hStdOut, coord);
     }
     return;
}