"Выравнивание" предложения добавлением необходимого числа пробелов

#include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <conio.h>
#include <ctime>
#include <locale>
 
 
using namespace std;
void vivod(char *p);//функция вывода строки
void preobr(char *x, int length); // функция выравнвания
int main()
{
    setlocale(LC_ALL,"Rus");
char str1[256],str2[256],str3[256];
char *p1=str1,*p2=str2,*p3=str3;[QUOTE]
int minlen=0,len;[/QUOTE]
cout<<"введите строку 1:"<<endl;
gets(p1);
 
cout<<"введите строку 2:"<<endl;
gets(p2);
 
cout<<"введите строку 3:"<<endl;
gets(p3);
if(minlen<strlen(p1))minlen=strlen(p1);
if(minlen<strlen(p2))minlen=strlen(p2);
if(minlen<strlen(p3))minlen=strlen(p3);
cout<<"задайте длину строки, не меньше "<<minlen<<":"<<endl;
cin>>len;
if(len<minlen){cout<<"ошибка"<<endl; return 0;}
 
preobr(p1,len);preobr(p2,len);preobr(p3,len);
vivod(p1);vivod(p2);vivod(p3);
return 0;
 
 
 
}
 
void vivod(char *p)
{
int i,len;
len=strlen(p);
for(i=0;i<=len;i++)
    cout<<p[i];
cout<<endl;
}
void preobr(char *x, int length)
{
 int i,len;
 char probeli[256];
 len=strlen(x);
 length-=len;
 for(i=0;i<=length;i++)  //делаем строку из недостающих пробелов
 {
    probeli[i]=' ';
    probeli[i+1]='\0';  //вставляем нулевой символ в конец стркои
 }
 strcat(probeli,x); //присоеденяем пробелы к x
 strcpy(x,probeli);
 probeli[0]='\0';
 
}

/////////////////////////////////////////////////////////////////////////////////////////
//Необходимо выровнять предложение. Выравнивание заключается в том, что необходимо получить 
//заданную длину предложения добавляя необходимое количество пробелов. Количество пробелов 
//не должно отличаться более чем на 1. Определить функцию для выравнивания предложения.
//(Надо сделать через функции).
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <cctype>
#include <iostream>
#include <iterator>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
/////////////////////////////////////////////////////////////////////////////////////////
void    trim_back( T_str    &   s )
{
    while   (
                    !s.empty()
 
                &&  std::isspace
                        (
                            s.back()
                        )
            )
    {
        s.pop_back();
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_compact_sentence( T_str     const   &   s )
{
    std::istringstream  ssin(s);
    std::ostringstream  sout;
 
    std::copy
        (
            std::istream_iterator<T_str>    ( ssin      ),
            std::istream_iterator<T_str>    (),
            std::ostream_iterator<T_str>    ( sout, " " )
        );
 
    T_str   res_s   =   sout.str();
    res_s.pop_back();
    return  res_s;
}
/////////////////////////////////////////////////////////////////////////////////////////
T_str   get_align_sentence
    (
        T_str   const   &   s,
        int                 res_s_size
    )
{
    auto    res_s(s);
 
    for (
            auto    symb_it         =   res_s.begin();
            int( res_s.size() )     <   res_s_size;
        )
    {
        symb_it     =   std::adjacent_find
                            (
                                symb_it,
                                res_s.end(),
 
                                []  (
                                        char    L,
                                        char    R
                                    )
 
                                {
                                        return          std::isspace(L)
                                                &&  !   std::isspace(R);
                                }
                            );
 
        symb_it     =   symb_it     ==  res_s.end()
                            ?   res_s.begin()
                            :   ++++res_s.insert
                                        (
                                            symb_it,
                                            ' '
                                        );
    }//for
 
    return  res_s;
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    for(;;)
    {
        T_str   s;
        T_str   compact_s;
 
        do
        {
            std::cout   <<  std::endl
                        <<  std::endl
                        <<  "Введите предложение из двух или более слов:"
                        <<  std::endl;
 
            std::cin.sync();
            getline( std::cin,  s );
            trim_back(s);
 
            if  (
                    s.empty()
                )
            {
                continue;
            }
 
            compact_s   =   get_compact_sentence(s);
        }
        while   (
                    compact_s.find(' ')     ==  T_str::npos
                );
 
        int     res_s_size  =   0;
 
        do
        {
            std::cout   <<  "Введите длину строки >= "
                        <<  compact_s.size()
                        <<  ": ";
 
            std::cin    >>  res_s_size;
        }
        while   (
                    res_s_size  <   int (
                                            compact_s.size()
                                        )
                );
 
        std::cout   <<  "Выровненная строка:"
                    <<  std::endl
 
                    <<  get_align_sentence
                            (
                                compact_s,
                                res_s_size
                            )
 
                    <<  std::endl;
    }//for
}

strcat(probeli,x); //присоеденяем пробелы к x
 strcpy(x,probeli);

на strcat(x,probeli);