#pragma comment(lib, "user32.lib"
    #pragma comment(lib, "kernel32.lib"
    #pragma comment(lib, "shell32.lib"
    
    #include <windows.h>

    #include <iostream>


    using namespace std;
    
//============= constants =======================================
    #define         STUDENT_COUNT 8     /* константа - кол-во элементов в массиве */
      
//============= structures ======================================
typedef struct STUDENT{
    char            name[128];
    int             group_ID;
    int             mark[5];
}STUDENT, *pSTUDENT;


    
//============= variables =======================================
    STUDENT*        array;              /* указатель на память, где сидит массив */
    int             sort_field_id;      /* переменная, указывающая по какому полю сортировать */
    


//===============================================================
static char* to_oem ( char* lpString )  /* перевод в дос-кодировку для отображения кириллицы*/
{
    char    buffer[512];
    CharToOem ( lpString, buffer );
    return ( buffer );
}

//===============================================================
int compare (STUDENT* index1, STUDENT* index2)  /* сравнение двух элементов */
{
    int             result=0;
    int             m1=0, m2=0;
    
    if ( sort_field_id==0 )
        result = _stricoll( index1->name, index2->name ); /*_stricoll - ф-ция сравнения строк*/

    else if ( sort_field_id==1 && index1->group_ID > index2->group_ID )
        result = 1;
    
    else if ( sort_field_id==2 )
    {
        /* считаем сумму оценок двух элементов и сравниваем их */
        for ( int i=0; i<5; i++ )
        {
            m1 += index1->mark[i];
            m2 += index2->mark[i];
        }
        if ( m1 > m2 ) result = 1;
    }
    /* если index1 > index2, возвращаем 1 (будем переставлять) */
    return result;

}

//==========================================================
void swap_index(STUDENT* index1, STUDENT* index2)   /* перестановка двух элементов */
{
    STUDENT     item;
    memcpy (&item, index1, sizeof(STUDENT));
    memcpy (index1,index2, sizeof(STUDENT));
    memcpy (index2, &item, sizeof(STUDENT));
}

//==========================================================
void sort( STUDENT* pArray, int count )     /* функция сортировки */
{
    int     swap;
    
    do
    {
        swap = 0;   /* флаг обмена */
        /* просмотр массива со сравнением соседних элементов */
        for ( int i=0; i<count-1; i++ )
        {
            if ( compare(&pArray[i], &pArray[i+1] > 0 )
            {
                /*если элемент с меньшим индексом оказался больше,
                  переставляем их местами и взводим флаг */
                swap_index(&pArray[i], &pArray[i+1];
                swap = 1;
            }
        }
    }
    /* повторяем цикл do - while пока были перестановки */
    while ( swap );
    
}

//==========================================================
static void fill_array( STUDENT* pArray, int count )
{
    char    buffer[128];
    int     pos;
    
    /* заполнение массива */
    for ( int i=0; i<count; i++ )
    {
        system("cls";
        printf ( to_oem("\n========= Студент № %lu ==========\n\n", i+1 );
        printf ( to_oem("Введите фамилию студента: " );
        cin >> pArray[i].name;
        pArray[i].name[ (pos = strlen (pArray[i].name)) ]=' ';
        pos++;
        printf ( to_oem("Введите имя студента: " );
        cin >> & pArray[i].name[pos++];
        pArray[i].name[pos++] = '.';
        printf ( to_oem("Введите отчество студента: " );
        cin >> & pArray[i].name[pos++];
        pArray[i].name[pos++] = '.';
        pArray[i].name[pos] = 0;
        printf ( to_oem("Введите номер группы: " );
        cin >> buffer;
        pArray[i].group_ID = atoi(buffer);  /* atoi - перевод строки в число int */
        printf ( to_oem("Введите 5 оценок, разделяя  запятыми /например: 1,5,3,4,2/: " );
        cin >> buffer;
        /* нечетные символы отметок преобразуем в цифры и в массив отметок */
        for ( int j=1; j<6; j++ )
            pArray[i].mark[j-1] = buffer[j-1)*2]-0x30;
    }

}

//==========================================================
static void pad_string ( char* string, int len )    /* дополнение строки пробелами до длины len */
{
    for ( int i = strlen(string); i<len; i++ )
        string[i]=' ';
    string[i]='|';
    string[i+1]=' ';
    string[i+2]=0;
}
        
//==========================================================
static void show_array( STUDENT* pArray, int count )    
{
    char    buffer[128];
    char    small_buffer[64];
    float   average;
    
    /* показываем массив со всеми полями + среднюю оценку */
    system ("cls";
    
    printf (       "\n    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
    printf ( to_oem ("    |  Ф И О студента         | Номер группы  |   Оценки   | Средний балл |\n" );
    printf (         "    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
    
    
    for ( int i=0; i<count; i++ )
    {
        average = 0;
        sprintf ( buffer, "    | %s", pArray[i].name );
        pad_string(buffer,30);

        sprintf (small_buffer, " %lu", pArray[i].group_ID );
        strcat  buffer, small_buffer);
        pad_string(buffer,46);

        for ( int j=0; j<5; j++ )
        {
            sprintf (small_buffer, "%lu ", pArray[i].mark[j] );
            strcat  buffer, small_buffer);
            average += pArray[i].mark[j];
        }
        pad_string(buffer,59);
        
        sprintf ( small_buffer, " %f", average/5 );
        strcat  buffer, small_buffer);
        pad_string(buffer,74);
        
        printf  "%s\n", buffer );
    }
    
    printf (         "    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++\n";
    
}

//==========================================================
char get_action()           /* получение выбора действия от юзера*/
{
    char    buffer[128];
    
    printf ( to_oem("\n\t\t===========================================\n" );
    printf ( to_oem("\t\t=    Выберите действие и нажмите ENTER    =\n" );
    printf ( to_oem("\t\t=       сортировать по имени  - 0         =\n" );
    printf ( to_oem("\t\t=       сортировать по группе - 1         =\n" );
    printf ( to_oem("\t\t=   сортировать по успеваемости  - 2      =\n" );
    printf ( to_oem("\t\t=        выйти из программы  - 3          =\n" );
    printf ( to_oem("\t\t===========================================\n" );
    printf ( to_oem("\t\t\t\tВыбор : " );
    
    /* запуск юзера по кольцу, пока не сделает выбор от 0 до 3*/
    while ( buffer[0]<'0' || buffer[0]>'3' )
        cin >> buffer;
    /* возвращаем выбор юзера */
    return ( buffer[0]-0x30 );
}

//==========================================================
int main()
{
    HANDLE      hStdout;
    
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout, FOREGROUND_BLUE|
                                     FOREGROUND_GREEN|
                                     FOREGROUND_INTENSITY);

    /* создаём, очищаем, заполняем и показываем массив*/
    array = new STUDENT[STUDENT_COUNT];    
    memset ( array, 0, STUDENT_COUNT*sizeof(STUDENT) );
    fill_array ( array, STUDENT_COUNT );
    show_array ( array, STUDENT_COUNT );
    
    
    /* пока юзер не нажмет 3, будем сортировать и показывать результат */
    while ( ( sort_field_id = get_action() ) != 3 )
    {
        sort ( array, STUDENT_COUNT );
        show_array ( array, STUDENT_COUNT );
    }
    
    /* уничтожаем массив, освобождая память*/
    delete[] array;
    
    /* выход из программы*/
    return 0;
}

обработку пробелов в ФИО (пришлось разбить на три отдельных ввода

    #define         STUDENT_COUNT 8     /* константа - кол-во элементов в массиве */

array = new STUDENT[STUDENT_COUNT];    

//==========================================================
void swap_index(STUDENT* index1, STUDENT* index2)   /* перестановка двух элементов */
{
    STUDENT     item;   /* временная локальная переменная типа STUDENT */

    /* memcpy - си-функция для копирования одного участка памяти в другой
       наподобие CopyMemory. 1-й параметр - адрес куда копировать, 2-й -адрес
       откуда копировать, 3-й -сколько байт копировать.
       1-й адрес (куда) - адрес переменной item. Сама переменная -item,
       а её адрес указывается со знаком & - &item
       2-й адрес у нас уже готовый есть - это указатель,переданный как параметр
       функции - index1.
       Количество байт для копирования указывается sizeof(STUDENT) - т.е.
       размер структуры STUDENT. И копируем элемент массива во временную переменную
       item на стеке.*/
    memcpy (&item, index1, sizeof(STUDENT));

    /* теперь на то место в массиве, где был элемент index1, копируем элемент index2
       точно таким же способом */
    memcpy (index1,index2, sizeof(STUDENT));

    /* и в заключение на место элемента index2 в массиве копируем старый элемент
       index1, который был спрятан во временной переменной. Так поменялись местами
       два куска памяти, соответствующие элементам index1 и index2 */
    memcpy (index2, &item, sizeof(STUDENT));
}

int main()
{
    HANDLE      hStdout, hStdin;
    char        buffer[128];
    
    hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
    SetConsoleTextAttribute(hStdout, FOREGROUND_BLUE|
                                     FOREGROUND_GREEN|
                                     FOREGROUND_INTENSITY);

    do
    {
        system ("cls"; /* очистка экрана */
        printf ( to_oem("\n\n\n\t\tВведите количество студентов /от 1 до 20/ : " );
        /* получаем количество студентов */
        cin >> buffer;
        /*переводим строку в int и сохраняем в глобальной переменной */
        STUDENT_COUNT = atoi(buffer);
    }
    /* если количество нас не устраивает (<1 или > 20), запрашиваем снова */
    while ( STUDENT_COUNT < 1 || STUDENT_COUNT > 20 );

    .....
    .....

char inBuf[ 1024 ];

int  cnt = 0;

while (cnt<3&&cin >> inBuf) {
       

char *str = new char[ strlen( inBuf ) + 1 ];
           strcpy( str, inBuf );
          cout << inBuf<<"\n";
  
   // ... сделать что-то с массивом символов str
           delete [] str;
    ++cnt;
}

//===============================================================
static int read_console ( char* lpBuffer, int buf_len ) /* получение ввода с клавиатуры */
{
    WORD       Read;
    int         i=0;

    if ( ReadConsole(hStdin, lpBuffer, buf_len, &Read, NULL) )
    {
        while ( i < Read && lpBuffer[i++] != 0xD);
        lpBuffer[i-1]=0;
        return (i-1);
    }
    return 0;
}

.......

    char    buffer[128];
    read_console( buffer, sizeof(buffer) );
    cout << buffer;

/* запуск юзера по кольцу, пока не сделает выбор от 0 до 3*/
    while ( buffer[0]<'0' || buffer[0]>'3' )
        cin >> buffer;
    /* возвращаем выбор юзера */
    return ( buffer[0]-0x30 );

char get_action()           /* получение выбора действия от юзера*/
{
char    buffer[128];

show_menu();
read_console( buffer, sizeof(buffer) );

/* запуск юзера по кольцу, пока не сделает выбор от 0 до 3*/
while ( buffer[0]<'0' || buffer[0]>'3' || buffer[0]==(sort_field_id+0x30) )
    {
     system("cls";
     if ( buffer[0]==(sort_field_id+0x30) )
            show_array ( array, STUDENT_COUNT );
     show_menu();
     read_console( buffer, sizeof(buffer) );
    }

Почему не сделать вместо while{} do{}while?