Создать класс angle, включающий указанные три поля - проверить правильность кода

#include <iostream>
#include <conio.h>
using namespace std;
class angle
{
    private:
        int grad; //градусы
        float min; //минуты
        char nprv; // направление
    public:
        angle(): grad(0), min(0), nprv(0)
        {}
        
        angle(int g, float m, char n): grad(g), min(m), nprv(n)
        {}
        
        void koord_tochki()
        {cin >> grad >> min >> nprv;}
        
        void show_koord()
        {cout << grad << ' ' << min << "'" << nprv;}    
};
int main()
{
    system("chcp 1251 > nul");  
    char yn = 'y';
    angle tchka(149, 34.8,'W');
    tchka.show_koord();
    do
    {
        cout << "\nВведите координаты точки: "; tchka.koord_tochki();
        cout << "Координаты равны: "; tchka.show_koord();
        cout << "\nПродолжать (y/n): ";
        cin >> yn;
    }while(yn != 'n');
    getch();
    return 0;
}

    setlocale( LC_ALL, "rus" );

    system( "pause" );

cout << endl;

/////////////////////////////////////////////////////////////////////////////////////////
//В морской навигации координаты точки измеряются в градусах, минутах широты и долготы. 
//Например: 149 градусов 34.8 минут восточной долготы и 17 градусов 31.5 минут южной широты. 
//Это записывается как . Один градус равен 60 минутам (устаревшая система также делила одну минуту 
//на 60 секунд, но сейчас минуту делят на обычные десятичные доли). Долгота измеряется величиной 
//от 0 до 180 градусов восточнее или западнее Гринвича. Широта принимает значения от 0 до 90 градусов 
//севернее или южнее экватора. 
//  Создайте класс angle, включающий следующие три поля: типа int 
//для числа градусов, типа float для числа минут и типа char для указания направления (N, S, Е или W). 
//Объект этого класса может содержать значение как широты, так и долготы. 
//  Создайте метод, позволяющий 
//ввести координату точки, направление, в котором она измеряется, 
//и метод, выводящий на экран значение 
//этой координаты, например 179°59.9 Е. 
//Кроме того, напишите конструктор, принимающий три аргумента. 
//
//  Напишите функцию mainQ, которая сначала создает переменную с помощью трехаргументного конструктора 
//и выводит ее значение на экран, а затем циклически запрашивает пользователя ввести значение координаты 
//и отображает введенное значение на экране.
/////////////////////////////////////////////////////////////////////////////////////////
#include <cctype>
#include <cmath>
#include <conio.h>
#include <iostream>
#include <sstream>
#include <string>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string     T_str;
typedef int             T_int_degree;
typedef double          T_real_minute;
/////////////////////////////////////////////////////////////////////////////////////////
enum    T_geo_direction
{
    N,
    S,
    E,
    W
};
/////////////////////////////////////////////////////////////////////////////////////////
class  T_geo_coord
{
    //-----------------------------------------------------------------------------------
    static const int    MINUTES_PER_DEGREE_ = 60;
    static const int    RIGHT_ANGLE_        = 90;
    static const int    DEGREE_PERIOD_      = 360;
    //-----------------------------------------------------------------------------------
    T_int_degree        int_degrees_;
    T_real_minute       real_minutes_;
    T_geo_direction     geo_direction_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_geo_coord
        (
            T_int_degree        degrees         =   0,
            T_real_minute       minutes         =   0,
            T_geo_direction     geo_direction   =   E
        )
        :
        int_degrees_    ( degrees       ),
        real_minutes_   ( minutes       ),
        geo_direction_  ( geo_direction )
    {
        normalize();
    }
    //-----------------------------------------------------------------------------------
    void  input()
    {
        print_prompt_and_input_val
            (
                "\n\n\nВведите географическую координату:\n\t"
                "градусы (целое значение)\t\t=\t",
                int_degrees_
            );
 
        print_prompt_and_input_val
            (
                "\tминуты (с плавающей точкой)\t\t=\t",
                real_minutes_
            );
 
        print_prompt_and_input_geo_direction( "\tгеографическое направление (N, S, E, W)\t=\t" );
 
        normalize();
    }
    //-----------------------------------------------------------------------------------
    T_str  str()    const
    {
        std::ostringstream  sout;
 
        sout    <<  int_degrees_
                <<  '°'
                <<  real_minutes_
                <<  ' ';
 
        switch( geo_direction_ )
        {
        case N:
            sout    <<  'N';
            break;
 
        case S:
            sout    <<  'S';
            break;
 
        case E:
            sout    <<  'E';
            break;
 
        case W:
            sout    <<  'W';
        }//switch
 
        return  sout.str();
    }
    //-----------------------------------------------------------------------------------
private:
    //-----------------------------------------------------------------------------------
    void  normalize()
    {
        T_real_minute   real_degrees    =   int_degrees_ + real_minutes_ / MINUTES_PER_DEGREE_;
 
        if( real_degrees < 0 )
        {
            real_degrees *= -1;
            change_geo_direction();
        }
 
        real_degrees    =   fmod    (
                                        real_degrees,
                                        DEGREE_PERIOD_
                                    );
 
        switch( geo_direction_ )
        {
        case N:
        case S:
            if( real_degrees >= RIGHT_ANGLE_ * 3 )
            {
                real_degrees = DEGREE_PERIOD_ - real_degrees;
                change_geo_direction();
            }
            else if( real_degrees >= RIGHT_ANGLE_ * 2 )
            {
                real_degrees = real_degrees - RIGHT_ANGLE_ * 2;
                change_geo_direction();
            }
            else if( real_degrees >= RIGHT_ANGLE_ )
            {
                real_degrees = RIGHT_ANGLE_ * 2 - real_degrees;
            }
            break;
        case E:
        case W:
            if( real_degrees >= RIGHT_ANGLE_ * 2 )
            {
                real_degrees = DEGREE_PERIOD_ - real_degrees;
                change_geo_direction();
            }
        }//switch
 
        T_real_minute   real_degrees_int_part;
        real_minutes_   =   modf( real_degrees, &real_degrees_int_part ) * MINUTES_PER_DEGREE_;
        int_degrees_    =   T_int_degree( real_degrees_int_part );
    }
    //-----------------------------------------------------------------------------------
    void  change_geo_direction()
    {
        switch( geo_direction_ )
        {
        case N:
            geo_direction_ = S;
            break;
 
        case S:
            geo_direction_ = N;
            break;
 
        case E:
            geo_direction_ = W;
            break;
 
        case W:
            geo_direction_ = E;
        }//switch
    }
    //-----------------------------------------------------------------------------------
    template<typename  T>
    void  print_prompt_and_input_val
        (
            const T_str&    prompt,
            T&              val
        )
    {
        std::cout   <<  prompt;
        std::cin    >>  val;
    }
    //-----------------------------------------------------------------------------------
    void  print_prompt_and_input_geo_direction( const T_str&  prompt )
    {
        char  geo_dir = 0;
 
        do
        {
            std::cout   <<  prompt;
 
            std::cin    >>  geo_dir;
            geo_dir     =   toupper( geo_dir );
        }
        while   (
                        geo_dir     !=  'N'
                    &&  geo_dir     !=  'S'
                    &&  geo_dir     !=  'E'
                    &&  geo_dir     !=  'W'
                );
 
        switch( geo_dir )
        {
        case 'N':
            geo_direction_ = N;
            break;
        case 'S':
            geo_direction_ = S;
            break;
        case 'E':
            geo_direction_ = E;
            break;
        case 'W':
            geo_direction_ = W;
        }//switch
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
void  demo_geo_coord()
{
    T_geo_coord     geo_coord
                        (
                            -1000000,
                            -1000000.5,
                            N
                        );
 
    std::cout   <<  geo_coord.str();
 
    for(;;)
    {
        geo_coord.input();
        std::cout   <<  geo_coord.str();
    }
}
/////////////////////////////////////////////////////////////////////////////////////////
int  main()
{
    std::locale::global(std::locale(""));
    T_geo_coord     geo_coord;
    demo_geo_coord();
    getch();
}