Написать функции для преобразования IP адреса из dot-decimal нотации в int и из int в dot-decimal нотацию

unsigned int encode(const std::string& ipAddress);
std::string decode(unsigned int code);

std::cout << decode(encode(“125.0.0.4”)) ; //prints 125.0.0.4
std::cout << encode(decode(19)) ; //prints 19

unsigned int encode(const std::string& ipAddress)
{
  unsigned int result = 0;
  string iP = ipAddress;
  unsigned char data =0;
  string num;
  while(iP.size())
  {
    if(iP[iP.size()-1] == '.')
    {
      data = atoi(num.c_str());
      result |=data;
      result<<8;
      iP.erase(iP.size()-1,1);
      data = 0;
      num.clear();
    } 
    else
    {
     num+=iP[iP.size()-1];
     iP.erase(0,1);
     
     }
  }
  data = atoi(num.c_str());
  result |=data;
 return result ;
}
 
 
std::string decode(unsigned int code)
{
 std::string result;
 unsigned char data =0;
 
 data|= code;
 result+=itoa(data);
 result+='.';
 
 code>>8;
 data = 0;
 data|= code;
 result+=itoa(data);
 result+='.';
 
 code>>8;
 data = 0;
 data|= code;
 result+=itoa(data);
 result+='.';
 
 code>>8;
 data = 0;
 data|= code;
 result+=itoa(data);
 
return result;
}

#include <iostream>
#include <sstream>
#include <vector>
#include <stdexcept>
 
unsigned int encode(const std::string& ipAddress);
std::string decode(const unsigned int code);
 
namespace 
{
 
std::vector<std::string> Split(const std::string& str, const char delim);
std::vector<std::string>& Split(const std::string& str, const char delim, std::vector<std::string>& elems);
int StringToInt(const std::string& str);
std::vector<unsigned char>& ParseOctets(const std::string& ipAddress, std::vector<unsigned char>& octets);
std::vector<unsigned char>& ExtractOctets(const unsigned int ip, std::vector<unsigned char>& octets);
std::string ConstructIpFromOctets(const std::vector<unsigned char>& octets);
 
std::vector<std::string> Split(const std::string& str, const char delim)
{
    std::vector<std::string> elems;
    
    Split(str, delim, elems);
    
    return elems;
}
 
std::vector<std::string>& Split(const std::string& str, const char delim, std::vector<std::string>& elems)
{
    std::stringstream stream(str);
    
    std::string item;
    
    while (std::getline(stream, item, delim))
    {
        if (!item.empty()) elems.push_back(item);
    }
    
    return elems;
}
 
int StringToInt(const std::string& str)
{
    int value = 0;
    
    std::stringstream stream(str);
    
    stream >> value;
    
    return value;
}
 
std::vector<unsigned char>& ParseOctets(const std::string& ipAddress, std::vector<unsigned char>& octets)
{   
    std::stringstream exceptionStream;
    
    bool errorOccurred = false;
    
    do
    {
        const size_t maxIpAddressLength = 15;
        const size_t minIpAddressLength = 7;
        
        if ((ipAddress.length() < minIpAddressLength) || (ipAddress.length() > maxIpAddressLength))
        {
            exceptionStream << "Invalid IP-address length. Expected: ["<< minIpAddressLength <<
                " - " << maxIpAddressLength << "], actual: " << ipAddress.length() << std::endl;
                
            errorOccurred = true;
            break;
        }
                
        std::vector<std::string> octetStrings = Split(ipAddress, '.');
        
        const size_t allowedOctetCount = 4;
        
        if (octetStrings.size() != allowedOctetCount)
        {
            exceptionStream << "Invalid octet count. Expected: " << allowedOctetCount << ", actual:" <<
                octetStrings.size() << std::endl;
            
            errorOccurred = true;
            break;
        }
        
        const int maxOctetValue = 255;
        
        std::vector<std::string>::size_type i = 0;
        
        while ((i != octetStrings.size()) && !errorOccurred)
        {
            int temp = StringToInt(octetStrings[i]);
        
            if ((temp < 0) || (temp > maxOctetValue))
            {
                exceptionStream << "Invalid octet #" << (i + 1) << ". Expected: [0 - " << maxOctetValue <<
                    "], actual: '" << temp << "'" << std::endl;
                    
                errorOccurred = true;
            }
            else octets.push_back((unsigned char)temp);
            
            i++;
        }
    }
    while (false);
    
    if (errorOccurred) throw std::invalid_argument(exceptionStream.str());
    
    return octets;
}
 
std::vector<unsigned char>& ExtractOctets(const unsigned int ip, std::vector<unsigned char>& octets)
{
    const unsigned char maxOffset = 24;
    
    unsigned char octet;
    
    for (unsigned char offset = 0; offset <= maxOffset; offset = offset + 8)
    {
        octet = (ip >> offset) & 0xFF;
        octets.push_back(octet);
    }
    
    return octets;
}
 
std::string ConstructIpFromOctets(const std::vector<unsigned char>& octets)
{
    std::stringstream stream;
    
    stream << (int)octets[3] << "." << (int)octets[2] << "." << (int)octets[1] << "." << (int)octets[0];
    
    return stream.str();
}
 
} // end namespace
 
unsigned int encode(const std::string& ipAddress)
{
    std::vector<unsigned char> octets;
 
    ParseOctets(ipAddress, octets);
    
    unsigned int result = (octets[0] * 16777216) + (octets[1] * 65536) + (octets[2] * 256) + octets[3];
    
    return result;
}
 
std::string decode(const unsigned int code)
{
    std::string ipAddress;
    
    std::vector<unsigned char> octets;
    
    ExtractOctets(code, octets);
    
    ipAddress = ConstructIpFromOctets(octets);
    
    return ipAddress;
}
 
int main(void)
{
    unsigned int ip;
    
    try
    {
        ip = encode("192.168.0.1");
        
        std::cout << ip << std::endl;
    }
    catch (const std::invalid_argument& e)
    {
        std::cout << e.what() << std::endl;
    }
    
    std::cout << decode(2449469064) << std::endl;
    
    std::cout << decode(encode("64.52.0.122")) << std::endl;
    
    return 0;
}

//IP-адрес - это четверка a.b.c.d, где a, b, c, d целые числа
//из интервала [0,255]. Требуется написать функции encode и decode:
 
//unsigned int encode(const std::string& ipAddress);
//std::string decode(unsigned int code);
 
//Первая функция превращает ай-пи адрес в четырех байтовое число.
//Функция decode выполняет обратный процесс. Неважно, как написаны функции.
//Главное, чтобы encode(decode(x)) было равно х для любого без знакового
//целого х; и чтобы decode(encode(strIp)) было равно strIp для любой строки,
//представляющей собой айпи адрес.
 
//std::cout << decode(encode(“125.0.0.4”)) ; //prints 125.0.0.4
//std::cout << encode(decode(19)) ; //pri
///////////////////////////////////////////////////////////////////////////////
#include <bitset>
#include <climits>
#include <iostream>
#include <sstream>
#include <string>
///////////////////////////////////////////////////////////////////////////////
const   int     NUMBERS_PER_ADDRESS     {4};
const   char    POINT_SYMB              {'.'};
///////////////////////////////////////////////////////////////////////////////
typedef std::string                     T_ip_adr;
typedef unsigned                        T_uint;
typedef std::bitset     < CHAR_BIT  >   T_byte_bitset;
///////////////////////////////////////////////////////////////////////////////
T_uint  encode( T_ip_adr    const   &   ip_adr )
{
    T_uint              res     {};
    std::istringstream  ssin    ( ip_adr );
    T_uint              val     {};
    char                delim   {};
 
    do
    {
        ssin    >>      val;
        res     <<=     CHAR_BIT;
        res     |=      val;
    }
    while( ssin >> delim );
 
    return  res;
}
///////////////////////////////////////////////////////////////////////////////
T_ip_adr    decode( T_uint   code )
{
    T_ip_adr    res_adr;
 
    for( int  i{}; i < NUMBERS_PER_ADDRESS; ++i )
    {
        res_adr     =       std::to_string
                                (
                                    T_byte_bitset( code ).to_ulong()
                                )
 
                        +   POINT_SYMB
                        +   res_adr;
 
        code        >>=     CHAR_BIT;
    }//for
 
    res_adr.pop_back();
    return  res_adr;
}
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::cout   <<  decode  (
                                encode("125.0.0.4")
                            )
 
                <<  std::endl
 
                <<  encode  (
                                decode(19)
                            )
 
                <<  std::endl;
}