Что такое октеты в IP-адресе?

Что такое октеты в IP-адресе?

Октет в IP-адресе — это 8-битное число (одна восьмёрка бит), которое может принимать значения от 0 до 255. IP-адрес версии 4 (IPv4) состоит из четырёх октетов, разделённых точками.

Структура IPv4-адреса

IP-адрес представляется в формате:

192.168.1.1
│   │   │ │
│   │   │ └─ Октет 4 (1)
│   │   └───── Октет 3 (1)
│   └───────── Октет 2 (168)
└───────────── Октет 1 (192)

Каждый октет — это 8 бит, всего 32 бита на адрес IPv4.

Двоичное представление

Пример разложения 192.168.1.1:

192 = 11000000 (в двоичной системе)
168 = 10101000
  1 = 00000001
  1 = 00000001

Полный адрес в двоичной системе:
11000000.10101000.00000001.00000001

Диапазон значений: Так как октет — это 8 бит, максимальное значение:

2^8 - 1 = 256 - 1 = 255

Диапазон каждого октета: 0 ... 255

Классы IP-адресов и октеты

Класс A:

Первый октет: 0 - 127
Пример: 10.0.0.1

Класс B:

Первый октет: 128 - 191
Пример: 172.16.0.1

Класс C:

Первый октет: 192 - 223
Пример: 192.168.1.1

Класс D (Multicast):

Первый октет: 224 - 239
Пример: 224.0.0.1

Класс E (Зарезервирован):

Первый октет: 240 - 255

Маска подсети и октеты

Маска подсети также состоит из четырёх октетов и используется для определения сетевой части и хост-части адреса:

IP-адрес:     192.168.1.100
Маска:        255.255.255.0

Сетевая часть: 192.168.1.0
Хост-часть:    0.0.0.100

В двоичной форме:

Маска 255.255.255.0:
11111111.11111111.11111111.00000000
 │       │       │       │
 │       │       │       └─ октет для хостов
 │       │       └───────── сетевой октет
 │       └───────────────── сетевой октет
 └───────────────────────── сетевой октет

Работа с октетами в коде (C/C++)

Преобразование строки в октеты:

#include <iostream>
#include <string>
#include <sstream>
#include <vector>

void parseIPAddress(const std::string& ip) {
    std::istringstream stream(ip);
    std::string octet;
    std::vector<int> octets;
    
    while (std::getline(stream, octet, '.')) {
        octets.push_back(std::stoi(octet));
    }
    
    for (int i = 0; i < octets.size(); ++i) {
        std::cout << "Octет " << (i + 1) << ": " 
                  << octets[i] << std::endl;
    }
}

// Использование
parseIPAddress("192.168.1.1");
// Вывод:
// Octет 1: 192
// Octет 2: 168
// Octет 3: 1
// Octет 4: 1

Работа с октетами через побитовые операции:

#include <iostream>
#include <cstdint>

struct IPv4Address {
    uint32_t address;  // 32 бита для всех четырёх октетов
    
    uint8_t getOctet(int index) const {
        // Индекс 0 = самый старший октет (первый)
        return (address >> (24 - index * 8)) & 0xFF;
    }
    
    void setOctet(int index, uint8_t value) {
        uint32_t mask = 0xFF << (24 - index * 8);
        address = (address & ~mask) | ((uint32_t)value << (24 - index * 8));
    }
    
    void print() const {
        std::cout << (int)getOctet(0) << "."
                  << (int)getOctet(1) << "."
                  << (int)getOctet(2) << "."
                  << (int)getOctet(3) << std::endl;
    }
};

int main() {
    IPv4Address addr;
    addr.address = 0xC0A80101;  // 192.168.1.1 в hex
    
    addr.print();  // 192.168.1.1
    
    std::cout << "Octет 1: " << (int)addr.getOctet(0) << std::endl;  // 192
    std::cout << "Octет 3: " << (int)addr.getOctet(2) << std::endl;  // 1
    
    addr.setOctet(3, 50);  // Установить 4-й октет = 50
    addr.print();  // 192.168.1.50
    
    return 0;
}

Валидация октетов:

bool isValidIPAddress(const std::string& ip) {
    std::istringstream stream(ip);
    std::string octet;
    int count = 0;
    
    while (std::getline(stream, octet, '.')) {
        try {
            int value = std::stoi(octet);
            if (value < 0 || value > 255) {
                return false;  // Октет вне диапазона
            }
            count++;
        } catch (...) {
            return false;  // Не число
        }
    }
    
    return count == 4;  // Должно быть ровно 4 октета
}

// Примеры:
isValidIPAddress("192.168.1.1");     // true
isValidIPAddress("256.1.1.1");       // false (256 > 255)
isValidIPAddress("192.168.1");       // false (только 3 октета)

Операции с октетами в сетях

AND операция для вычисления сетевого адреса:

uint32_t getNetworkAddress(uint32_t ip, uint32_t mask) {
    return ip & mask;
}

// Пример:
// IP:   192.168.1.100 = 11000000.10101000.00000001.01100100
// Mask: 255.255.255.0  = 11111111.11111111.11111111.00000000
// AND:  192.168.1.0    = 11000000.10101000.00000001.00000000

Определение принадлежности адреса подсети:

bool isInSubnet(uint32_t ip, uint32_t subnet, uint32_t mask) {
    return (ip & mask) == (subnet & mask);
}

// Пример: 192.168.1.50 принадлежит сети 192.168.1.0/24?
// (192.168.1.50 & 255.255.255.0) == (192.168.1.0 & 255.255.255.0)
// 192.168.1.0 == 192.168.1.0 → true

Практические применения в Backend

IP-фильтрация:

bool isPrivateIP(const std::string& ip) {
    // 10.0.0.0/8
    // 172.16.0.0/12
    // 192.168.0.0/16
    // Парсим первый октет и проверяем
}

Балансировка нагрузки: Использование последнего октета для распределения клиентов между серверами:

int getServerIndex(const std::string& clientIP, int serverCount) {
    int lastOctet = std::stoi(clientIP.substr(clientIP.rfind('.') + 1));
    return lastOctet % serverCount;
}

Логирование и мониторинг: Парсинг октетов для анализа трафика по странам (geo-IP) и регионам сети.