Optymalizacja kodu prymitywnej bazy

#include "golf.h"
#include <iostream>
#include <cstring>

using std::cout;
using std::endl;
using std::cin;
using std::string;

void makestr( char ch, int signs )
{
    for( int i = 0; i < signs; ++i )
    {
        cout << ch;
    }
    cout << endl;
}

string makestr( string str, char ch, int signs )
{
    str = "";
    for( int i = 0; i < signs; ++i )
    {
        str[ i ] = ch;
    }
    return str;
}

void setgolf( golf & g, const char * name, int hc )
{
   
    if( name == '\0' )
    {
        cout << "Pusty parametr w konstruktorze (nazwisko)" << endl << "Podaj prawidlowy parametr: ";
       
        while( !( cin.get( g.fullname, cLen ) ) )
        {
            cin.clear();
            cin.ignore();
            cout << "Podaj prawidlowy parametr: ";
        }
    }
    else
    {
        strncpy( g.fullname, name, 40 );
    }
    if( hc <= 0 || !hc )
    {
        cout << "Zly handicap w konstruktorze, podaj prawidlowy: ";
        while( !( cin >> hc ) || hc <= 0 || hc == '\0' )
        {
            cin.clear();
            cin.ignore();
            cout << "Podaj prawidlowy handicap: ";
        }
    }
    g.handicap = hc;
    g.fullname[ 0 ] = toupper( g.fullname[ 0 ] );
}

void setgolf( golf & g )
{
    cout << "Podaj nazwisko: ";
    if( !( cin.get( g.fullname, 40 ) ) )
    {
        while( !( cin.get( g.fullname, 40 ) ) )
        {
            cin.clear();
            cin.ignore();
            //cout << "Podaj prawdilowe nazwisko: ";
        }
    }
    cout << "Podaj handicap: ";
    if( g.handicap >= 0 || !( cin >> g.handicap ) )
    {
        while( !( cin >> g.handicap ) || g.handicap <= 0 )
        {
            cin.clear();
            cin.ignore();
            cout << "Handicap nie moze byc ani pusty ani ujemny: ";
        }
    }
    g.fullname[ 0 ] = toupper( g.fullname[ 0 ] );
}

void deletegolf( golf & g )
{
    strncpy( g.fullname, "", 40 );
    g.handicap = 0;
}

void handicap( golf & g, int hc )
{
    g.handicap = hc;
    if( g.handicap <= 0 )
    {
        cout << "Zly handicap w konstruktorze, podaj prawidlowy: ";
        while( !( cin >> g.handicap ) || g.handicap <= 0 )
        {
            cin.clear();
            cin.ignore();
            cout << "Podaj prawidlowy handicap: ";
        }
    }
   
}

void showgolf( const golf & g )
{
    cout << "Gracz " << g.fullname << ", handicap: " << g.handicap << endl;
}

void showall( const golf g[], int tSize )
{
    cout << "Oto nasi zawodnicy: " << endl;
    int i;
    int count = 0;
    for( i = 0; i < tSize; ++i )
    {
        if( strcmp( g[ i ].fullname, "" ) )
        {
            if( i == 0 )
                 makestr( '-', 20 );
           
            cout << i + 1 << ". " << g[ i ].fullname << ", " << g[ i ].handicap << endl;
            ++count;
        }
    }
    if( count == 0 )
         cout << "Brak." << endl;
    else
         makestr( '-', 20 );
   
}

void menu( golf g[], int tSize )
{
    int manage;
    const golf * ptable = g;
    cout << "Wybierz 1 aby dodac gracza, 2 aby usunac i 3 aby wyswietlic graczy: ";
    while( !( cin >> manage ) )
    {
        cin.clear();
        cin.ignore();
        cout << "Podaj 1, 2 lub 3!";
    }
    if( manage == 1 )
    {
        int i = 0;
        while(( strcmp( g[ i ].fullname, "" ) ) )
             ++i;
       
        cout << "Wolne miejsce: " << i + 1 << endl;
        setgolf( g[ i ] );
        showgolf( g[ i ] );
    }
    else if( manage == 2 )
    {
        showall( ptable, tSize );
        int id;
        cout << "Podaj id gracza ktorego chcesz usunac: ";
        while( cin >> id && id < 0 );
       
        id -= 1;
        deletegolf( g[ id ] );
    }
    else if( manage == 3 )
    {
        showall( ptable, tSize );
    }
    else
    {
        cout << "Bledne dane :(" << endl;
    }
}

// File golf.hpp
#ifndef GOLF_HPP_INCLUDED
#define GOLF_HPP_INCLUDED

#include <ostream>
#include <utility>

template < typename T, T Upper, T Lower >
struct limits
{
    using type = T;
    static constexpr inline T upper = Upper;
    static constexpr inline T lower = Lower;
};

template < typename Name, typename NameLimits, typename Handicap, typename HandicapLimits >
class golf
{
public:
    using name_type = Name;
    using handicap_type = Handicap;
   
    using name_limits = NameLimits;
    using handicap_limits = HandicapLimits;
   
    golf() = default;
   
    golf( const golf < Name, NameLimits, Handicap, HandicapLimits >& ) = default;
   
    golf( golf < Name, NameLimits, Handicap, HandicapLimits >&& ) = default;
   
    golf < Name, NameLimits, Handicap, HandicapLimits >& operator =( const golf < Name, NameLimits, Handicap, HandicapLimits >& ) = default;
   
    golf < Name, NameLimits, Handicap, HandicapLimits >& operator =( golf < Name, NameLimits, Handicap, HandicapLimits >&& ) = default;
   
    template < typename Other >
    bool fullname( Other && other )
    {
        if( other.size() <= name_limits::upper && other.size() >= name_limits::lower ) {
            this->fullname_ = std::forward < Other >( other );
            this->empty_ = false;
            return true;
        }
        return false;
    }
   
    template < typename Other >
    bool handicap( Other && other )
    {
        if( other <= handicap_limits::upper && other >= handicap_limits::lower ) {
            this->handicap_ = std::forward < Other >( other );
            this->empty_ = false;
            return true;
        }
        return false;
    }
   
    const name_type & fullname() const
    { return this->fullname_; };
   
    const handicap_type & handicap() const
    { return this->handicap_; };
   
    void clear()
    { this->empty_ = true; };
   
    bool empty() const
    { return this->empty_; };
   
private:
    name_type fullname_;
    handicap_type handicap_;
    bool empty_ = true;
};

template < typename Name, typename NameLimits, typename Handicap, typename HandicapLimits >
std::ostream & operator <<( std::ostream & os, const golf < Name, NameLimits, Handicap, HandicapLimits >& g ) {
    os << "Gracz ";
    os.write( g.fullname().data(), g.fullname().size() );
    os << ", handicap: " << g.handicap();
    return os;
}

#endif // GOLF_HPP_INCLUDED

// File utils.hpp
#ifndef UTILS_HPP_INCLUDED
#define UTILS_HPP_INCLUDED

#include <algorithm>
#include <array>
#include <iostream>
#include <iterator>
#include <limits>
#include <sstream>
#include <string>

template < typename String >
String get_line()
{
    // Nie jest to najlepsze podejście...
    String res;
    std::getline( std::cin, res );
    std::cin.clear();
    // std::cin.ignore();
    return res;
}

template < typename To, typename String >
bool str_cast( To & to, const String & str )
{
    if( str.size() == 0 )
         return false;
   
    std::istringstream iss( str.c_str() );
    iss >> to;
   
    if( iss && iss.eof() )
         return true;
   
    return false;
}

template < typename Golf >
void set_handicap( Golf & g )
{
    using handicap_type = typename Golf::handicap_type;
   
    auto load =[ & g ]()->bool {
        handicap_type hc;
        return !str_cast < handicap_type >( hc, get_line < std::string >() ) || !g.handicap( hc );
    };
   
    std::cout << "Podaj handicap: ";
    while( load() )
         std::cout << "Błędny handicap, podaj prawidlowy: ";
   
}

template < typename Golf >
void set_fullname( Golf & g )
{
    using fullname_type = typename Golf::name_type;
   
    auto load =[ & g ]()->bool {
        auto str = get_line < std::string >();
        fullname_type fn( str.data(), str.size() );
        return !g.fullname( fn );
    };
   
    std::cout << "Podaj nazwisko: ";
    while( load() )
         std::cout << "Błędne nazwisko, podaj prawidlowe: ";
   
}

template < typename GolfIterator >
void display_all( GolfIterator begin, GolfIterator end )
{
    std::cout << "Oto nasi zawodnicy: " << std::endl;
   
    bool first = true;
    auto display =[ & first ]( size_t pos, const auto & g ) {
        if( first ) {
            std::fill_n( std::ostream_iterator < char >( std::cout ), 20, '-' );
            std::cout << std::endl;
        }
       
        std::cout << pos + 1 << " " << g << std::endl;
        first = false;
    };
   
    size_t count = 0;
    std::for_each( begin, end,[ & count, & display ]( const auto & g ) {
        if( !g.empty() )
             display( count, g );
       
        count += 1;
    } );
   
    if( first )
         std::cout << "Brak." << std::endl;
    else {
        std::fill_n( std::ostream_iterator < char >( std::cout ), 20, '-' );
        std::cout << std::endl;
    }
}

inline bool get_idx( size_t & idx, size_t limit )
{
    if( !str_cast < size_t >( idx, get_line < std::string >() ) )
         return false;
   
    idx -= 1;
    if( idx >= limit )
         return false;
   
    return true;
}

template < typename GolfArray >
void menu( GolfArray & array )
{
    std::array < void( * )( GolfArray & ), 3 > action;
    action.fill( nullptr );
   
    action[ 0 ] =[]( GolfArray & a ) {
        bool stop = false;
        size_t i = std::count_if( a.begin(), a.end(),[ & stop ]( const auto & g )->bool { return !( stop =( stop ? true: g.empty() ) ); } );
       
        if( i >= a.size() ) {
            std::cout << "Brak wolnego miejsca." << std::endl;
            return;
        }
       
        std::cout << "Wolne miejsce: " << i + 1 << std::endl;
       
        set_fullname( a[ i ] );
        set_handicap( a[ i ] );
       
        std::cout << a[ i ] << std::endl;
    };
   
    action[ 1 ] =[]( GolfArray & a ) {
        display_all( a.begin(), a.end() );
        size_t id;
        std::cout << "Podaj id gracza ktorego chcesz usunac: ";
        while( !get_idx( id, a.size() ) )
             std::cout << "Podaj id gracza ktorego chcesz usunac: ";
       
        a[ id ].clear();
    };
   
    action[ 2 ] =[]( GolfArray & a ) {
        display_all( a.begin(), a.end() );
    };
   
    size_t idx = 0;
    std::cout << "Wybierz 1 aby dodac gracza, 2 aby usunac i 3 aby wyswietlic graczy: ";
    while( !get_idx( idx, action.size() ) )
         std::cout << "Podaj 1, 2 lub 3: ";
   
    action[ idx ]( array );
}

#endif // UTILS_HPP_INCLUDED