Code Habit

서버 네트워크 성능 측정하기

코드베어 — Sat, 12 Oct 2024 18:20:23 +0900

리눅스 서버에서 네트워크를 점검할 때 많이 사용하는 iperf3와 네트워크 트래픽 측정 관련 shell을 정리해보려 한다.

간단한 툴이지만 실제 회사업무에서 서버 네트워크 상태를 체크하는데 유용하게 사용했다.

1. CentOS에 iperf3 설치하기

sudo dnf install iperf3

2. iperf3 사용하기

2.1 서버모드 실행

iperf3 -s

2.2 클라이언트 모드로 접속하기

iperf3 -c server_ip

2.3 결과 ( 클라이언트 모드 )

server 역할을 수행할 서버에서 서버모드로 iperf3를 실행 후 타 서버에서 클라이언트 모드로 접속하면 위와 같이 초당 네트워크 전송량을 측정해준다. 전송량을 따로 명시하지 않으면 NIC카드가 허용하는 최대치까지 전송해 준다.

초당 전송량은 900MBytes정도며 Retr(재전송 횟수)는 평균적으로 0임을 알 수 있다. 참고로 재전송 횟수는 적을수록 안정적이다.

3. 네트워크 트래픽 측정 쉘

while true
do
    # 현재의 bytes 값을 읽어옴 (Receive와 Transmit)
    RX_BYTES_1=$(cat /proc/net/dev | grep $INTERFACE | awk '{print $2}')
    TX_BYTES_1=$(cat /proc/net/dev | grep $INTERFACE | awk '{print $10}')

    sleep 1  # 1초 동안 대기

    # 1초 후의 bytes 값을 읽어옴 (Receive와 Transmit)
    RX_BYTES_2=$(cat /proc/net/dev | grep $INTERFACE | awk '{print $2}')
    TX_BYTES_2=$(cat /proc/net/dev | grep $INTERFACE | awk '{print $10}')

    # 초당 전송량 계산 (바이트)
    RX_RATE=$((RX_BYTES_2 - RX_BYTES_1))
    TX_RATE=$((TX_BYTES_2 - TX_BYTES_1))

    # 바이트를 Mbps로 변환
    RX_Mbps=$(echo "scale=2; $RX_RATE * 8 / 1000000" | bc)
    TX_Mbps=$(echo "scale=2; $TX_RATE * 8 / 1000000" | bc)

    # 결과 출력
    echo "RX: $RX_Mbps Mbps, TX: $TX_Mbps Mbps"
done

위 쉘을 실행하면 초당 네트워크 트래픽 ( RX / TX )를 측정할 수 있다.

C++ 에서 YAML 다루기 : yaml-cpp 시작하기

코드베어 — Thu, 10 Oct 2024 23:24:25 +0900

YAML 파일은 간결하고 직관적인 데이터 구조를 표현하는 형식으로 구성 파일에 주로 사용된다. yaml-cpp는 c++언어에서 yaml파일을 다룰 수 있는 강력한 라이브러리로, 다양한 yaml 기능을 지원하며 설치가 쉽고 사용이 간편하다. 이 글에서는 yaml-cpp의 기본적인 사용법을 단계별로 알아보겠다.

1. yaml-cpp 설치하기

1.1 git code 다운, 빌드 & 설치

git clone https://github.com/jbeder/yaml-cpp.git

cd yaml-cpp
mkdir build
cd build
cmake ..
make
sudo make install

1.2 CMakeLists.txt 파일에 yaml-cpp 라이브러리 추가

find_package(yaml-cpp REQUIRED)
target_link_libraries(your_project_name yaml-cpp)

2 yaml-cpp 사용 예제

2.1 yaml 파일예제

name: "Example"
version: 1.0
dependencies:
  - yaml-cpp
  - boost
  - fmt

2.2 yaml 사용예제 ( cpp )

#include <yaml-cpp/yaml.h>
#include <iostream>
#include <string>

int main() {
    YAML::Node config = YAML::LoadFile("example.yaml");

    // 단일 값 읽기
    std::string name = config["name"].as<std::string>();
    double version = config["version"].as<double>();

    // 배열 값 읽기
    for (auto dep : config["dependencies"]) {
        std::cout << "Dependency: " << dep.as<std::string>() << std::endl;
    }

    std::cout << "Name: " << name << "\nVersion: " << version << std::endl;
    return 0;
}

2.3 더 복잡한 구조 읽기

person:
  name: "John Doe"
  age: 30
  address:
    street: "1234 Main St"
    city: "Hometown"

YAML::Node person = config["person"];
std::string name = person["name"].as<std::string>();
int age = person["age"].as<int>();
std::string street = person["address"]["street"].as<std::string>();
std::string city = person["address"]["city"].as<std::string>();

[python] 간단한 http request client 구현

코드베어 — Sun, 9 Jun 2024 12:28:39 +0900

회사 작업 중 서버를 Active/Pause 상태로 변환하는데 http 통신을 할 필요가 있어 파이썬으로 간단하게 구현해 보았다.

필요요구 사항과 구현된 프로그램 특징은 다음과 같다.

- 프레임 크기에 따른 체크박스 자동 배치 ( 줄 바꿈 처리 )

- 성공/실패 여부 Text로 출력하면서 자동 스크롤 되는 debug 창 필요.

- 파이썬 기본 내장 라이브러리인 tkinter 사용하여 간단한 ui 구현 ( 체크박스, push 버튼, Debug Text 창 )

- 파이썬 requests 라이브러리 사용하여 http request 구현

import tkinter as tk
import requests
from dataclasses import dataclass
from tkinter import scrolledtext

@dataclass
class Address:
    host:str
    ip:str
    checked:bool

addresses = [
     Address("hostname_1", "127.0.0.1", False),
     Address("hostname_2", "127.0.0.1", False),
     Address("hostname_3", "127.0.0.1", False),
     Address("hostname_4", "127.0.0.1", False),
]

def on_connect_button_click():
    for addr in addresses:  
        if(addr.checked.get() == True):
            url = f"http://{addr.ip}:8060/connect_request?key=server1"
            if send_request_get(url) == False:
                add_debug_info(f"Failed to Request Connect nats {addr.host}")
            else:
                add_debug_info(f"Success to Request Connect nats {addr.host}")

def on_disconnect_button_click():
    for addr in addresses:
        if(addr.checked.get() == True):
            url = f"http://{addr.ip}:8060/disconnect_request?key=server1"
            if send_request_get(url) == False:
                add_debug_info(f"Failed to Request Disconnect nats {addr.host}")
            else:
                add_debug_info(f"Success to Request Disconnect nats {addr.host}")
                
def on_reset_button_click():
    for addr in addresses:
        addr.checked.set(False)

def send_request_get(url) -> bool:
    result = True
    try:
        response = requests.get(url)
        if response.status_code == 200:
            result = True
        else:
            result = False
    except requests.RequestException as e:
        result = False

    return result

def add_debug_info(message):
    debug_area.insert(tk.END, message + "\n")
    debug_area.yview(tk.END)  # 자동 스크롤

root = tk.Tk()
root.title("transcoder connect")

frame = tk.Frame(root)
frame.pack(fill='both', expand=True)

row = 0
checkboxes = []
for addr in addresses:
    var = tk.BooleanVar()
    addr.checked = var
    checkbutton = tk.Checkbutton(frame, text=addr.host, variable=var)
    checkboxes.append(checkbutton)
    row += 1

# 체크박스 배치 및 프레임 넓이에 따라 자동 줄 바꿈 배치
def place_checkboxes():
    row, column = 0, 0
    frame.update_idletasks()  # 현재 프레임의 크기 업데이트
    frame_width = frame.winfo_width()  # 프레임의 너비
    padding = 5  # 적당한 패딩 값
    current_width = padding

    for checkbox in checkboxes:
        checkbox.grid_forget()  # 이전 그리드 설정을 초기화
        checkbox_width = checkbox.winfo_reqwidth()  # 체크박스의 요청 너비
        if current_width + checkbox_width > frame_width:
            row += 1
            column = 0
            current_width = padding
        checkbox.grid(row=row, column=column, sticky="w", padx=padding, pady=padding)
        current_width += checkbox_width + padding
        column += 1
        
# 초기 체크박스 배치
place_checkboxes()

# 창 크기 변경 시 체크박스 재배치
root.bind('<Configure>', lambda e: place_checkboxes())

button = tk.Button(root, text="connect", command=on_connect_button_click)
button.pack()

button2 = tk.Button(root, text="disconnect", command=on_disconnect_button_click)
button2.pack()

button3 = tk.Button(root, text="reset", command=on_reset_button_click)
button3.pack()

debug_area = scrolledtext.ScrolledText(root, wrap=tk.WORD)
debug_area.pack()

# 시작 !
add_debug_info("Initializing system...")

root.mainloop()

기능 요구사항이 복잡하지 않아 간단하게 구현할 수 있는 파이썬을 사용하였고 갠적으로는 주로 쓰는 언어가 아니라 코드가 좀 엉성할 수 있다 .. ㅎㅎ;

Singleton pattern

코드베어 — Mon, 12 Feb 2024 13:14:45 +0900

싱글턴 패턴은 소프트웨어 디자인 패턴 중 하나로 프로그램 내에 인스턴스가 오직 하나만 존재하도록 보장하는 패턴이다. 이 패턴은 전역 변수를 사용하지 않고 객체의 단일 인스턴스에 대한 전역적인 접근을 제공한다.

- example

#ifndef _SINGLE_TON_TMPL_
#define _SINGLE_TON_TMPL_

#include <cstddef>

template <typename T>
class Singleton_tmpl : public T
{
public:
    Singleton_tmpl() {}
    ~Singleton_tmpl() {}

    static Singleton_tmpl *GetInstance()
    {
        if (Singleton_tmpl::m_pInstance == nullptr)
        {
            Singleton_tmpl::m_pInstance = new Singleton_tmpl;
        }

        m_nRefs++;
        return m_pInstance;
    }

    void Release()
    {
        if (m_nRefs > 0)
        {
            m_nRefs--;

            if ((m_nRefs == 0) && (m_pInstance))
            {
                delete m_pInstance;
                m_pInstance = nullptr;
            }
        }
    }

private:
    static int m_nRefs;
    static Singleton_tmpl *m_pInstance;
};

// init staic variables 
template <typename T> Singleton_tmpl<T> *Singleton_tmpl<T>::m_pInstance = NULL;
template <typename T> int                Singleton_tmpl<T>::m_nRefs = 0; 

#endif

특정 클래스 T를 상속받는 클래스를 정의하였다. 클래스 내 정적멤버 변수 m_pInstance, m_nRefs를 선언하여 싱글톤 인스턴스를 관리하며 클래스 외부에서 정적 멤버 변수들을 초기화 하고 있다.

사용 예제이다.

Singleton_tmpl<CDerivedClass> *pDrCls;
pDrcls = Singleton_tmpl::GetInstance();

pDrcls->Functions();

if(pDrCls) 
{
    pDrCls->Release();
    pDrcls = nullptr;
}

T타입으로 CDerivedClass를 사용하는 객체 변수를 선언하여 Getinstance()로 인스턴스를 할당 받는다. 처음 할당 받으면 인스턴스 생성과 동시에 m_nRefs값이 1이 되며 생성된 인스턴스가 반환될 것이고 이미 생성되어 있다면 m_nRefs 값이 1 증가하며 미리 생선된 인스턴스가 반환될 것이다.

사용이 완료된 pDrCls는 Release()를 호출하여 인스턴스 카운팅(m_nRefs)을 하나 줄이거나 인스턴스를(m_pInstance)를 해제 시킨다.

epoll

코드베어 — Fri, 9 Feb 2024 11:23:41 +0900

epoll은 리눅스에서 고성능 네트워크 프로그래밍을 위해 사용되는 I/O 이벤트 알림 모델이다. 대규모 파일 디스크럽터를 효율적으로 관리하며 이는 서버가 많은 수의 클라이언트와 동시에 통신해야 하는 고성능 네트워크 애플리케이션에 매우 유용하다.

- epoll_create

int epoll_create(int size);

size만큼의 입출력 이벤트를 저장할 공간을 만든다. 그러나 리눅스 2.6.8 부터는 커널이 필요한 데이터의 크기를 동적으로 조정하기 때문에 0보다 큰 값만 입력하면 된다.

- epoll_ctl

int epoll_ctl(int epfd, int op, int fd, struct epoll_events *event);

epoll에 fd를 등록/수정/삭제 하는 함수로 epoll에서 관심있는 fd와 이 fd에서 발생할 event를 등록할 수 있다.

op에 fd의 등록/변경/삭제를 결정하는 옵션들을 지정할 수 있다. ( EPOLL_CTL_ADD / EPOLL_CTL_MOD / EPPOL_CTL_DEL )

- epoll_wait

int epoll_wait(int epfd, struct epoll_evnet *events, int maxevents, int timeout);

관심있는 fd들에게 무슨 일이 있었는지 검사한다. 검출할 사건들의 리스트를 events->events[]로 전달하고 이벤트가 발생하면 발생한 이벤트 수를 리턴받는다. maxevents로 한번에 전달 받을 이벤트의 최대값을 지정할 수 있고 timeout으로 이벤트를 기다리는 시간을 밀리세컨드 단위로 전달할 수 있는데 -1을 전달하면 계속해서 이벤트를 기다리는 blocking 상태고 되고 0을 전달하면 이벤트 유무만 검사하고 즉시 리턴하는 상태가 된다.

- example

#include<cstdio>
#include <iostream>
#include <string.h>
#include <fcntl.h>

using namespace std;

#include <sys/unistd.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#include <arpa/inet.h>

#define SERVER_PORT 7001
#define BACKLOG 10
#define MAX_EVENTS 1000;

void setnonblocking(int sock)
{
    int flag = fcntl(sock, F_GETFL, 0);
    fcntl(sock, F_SETFL, flag | O_NONBLOCK);
}

int setup_socket()
{
    int sock;
    struct sockaddr_in sin;

    if ((sock = socket(PF_INET, SOCK_STREAM, 0)) < 0)
    {
        return -1;
    }

    memset(&sin, 0, sizeof sin);

    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl(INADDR_ANY);
    sin.sin_port = htons(SERVER_PORT);

    if (bind(sock, (struct sockaddr *)&sin, sizeof sin) < 0)
    {
        close(sock);
        return -1;
    }

    if (listen(sock, BACKLOG) < 0)
    {
        close(sock);
        return -1;
    }

    return sock;
}

int main()
{
    int server_fd = 0;
    int epoll_fd = 0;
    struct epoll_event event;
    struct epoll_event events[MAX_EVENTS];
    int event_count = 0;
    char buffer[1024] = {
        0,
    };

    // setup socket
    server_fd = setup_socket();
    if (server_fd < 0)
    {
        return 0;
    }

    // create epoll fd
    epoll_fd = epoll_create(100);
    if (epoll_fd < 0)
    {
        close(server_fd);
        return 0;
    }

    // set event
    memset(&event, 0, sizeof event);
    event.events = EPOLLIN | EPOLLHUP;
    event.data.fd = server_fd;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &event) < 0)
    {
        close(server_fd);
        close(epoll_fd);
        return 0;
    }

    while (true)
    {
        event_count = epoll_wait(epoll_fd, epoll_events, MAX_EVENTS, 100);
        for (int i = 0; i < event_count; i++)
        {
            // accept
            if (epoll_events[i].data.fd == server_fd)
            {
                struct sockaddr_in client_addr;
                socklen_t client_addr_len = sizeof client_addr;

                int client_fd = accept(server_fd, (struct sockaddr_in *)&client_addr, (socklen_t *)&client_addr_len);
                if (client_fd < 0)
                {
                    continue;
                }

                // set client_fd non-block
                setnonblocking(client_fd);

                // set event
                memset(&event, 0, sizeof event);
                event.events = EPOLLIN | EPOLLHUP;
                event.data.fd = client_fd;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event) < 0)
                {
                    close(client_fd);
                    continue;
                }
            }
            else
            {
                int client_fd = events[i].data.fd;
                int n = read(client_fd, buffer, buffer_fd);
                if (n < 0)
                { // error
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, &event);
                    close(client_fd);
                }
                else if (n == 0)
                { // client close
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, client_fd, &event);
                    close(client_fd);
                }
                else
                { // read data
                    write(client_fd, buffer, n); // write echo message
                }
            }
        }
    }

    return 0;
}

server socket을 셋팅하고 epoll에 등록하여 client 접속 및 메시지를 처리하는 예제이다. 메시지를 받으면 받은 메시지를 바로 write하여 간단한 echo 역할을 수행한다.

참고 ) https://jacking75.github.io/choiheungbae/문서/epoll을%20사용한%20비동기%20프로그래밍.pdf

[c++] Nats Client

코드베어 — Sun, 4 Feb 2024 12:12:36 +0900

Nats는 오픈소스 메시징 시스템을 지원하는 서비스의 한 종류로 다양한 응용프로그램 간의 효율적인 통신을 지원한다. 기본적으로 publisher와 subscriber로 구성되어 있으며 다양한 프로그래밍 언어에 대한 클라이언트 라이브러리를 제공하므로 다양한 언어로 작성된 애플리케이션 간의 통신을 할 수 있다.

c++로 작성된 client 예제이다.

#include <iostream>
#include <nats/nats.h>

void messageHandler(natsConnection* conn, natsSubscription* sub, natsMsg* msg, void* closure)
{
    // get data
    const char* data = natsMsg_GetData(msg);
    int dataLen = natsMsg_GetDataLength(msg);

    // print data
    std::cout << "Received message: " << std::string(data, dataLen) << std::endl;

    // free msg
    natsMsg_Destroy(msg);
}

int main() 
{
    natsConnection* conn = NULL;
    natsOptions* opts = NULL;
    natsSubscription* subscription = NULL;
    natsMsg* msg = NULL;
    natsStatus status;

    // create opt
    status = natsOptions_Create(&opts);
    if (status != NATS_OK) {
        std::cerr << "Error creating NATS options : " << natsStatus_GetText(status) << std::endl;
        return 1;
    }

    // set servers to opt
    const char* servers[] = {"nats://server1:4222", "nats://servers:4222"};
    status = natsOptions_SetServers(opts, servers, 2);
    if (status != NATS_OK) {
        std::cerr << "Error setting NATS Server URLs : " << natsStatus_GetText(status) << std::endl;
        natsOptions_Destroy(opts);
        return 1;
    }

    // connect nats server
    status = natsConnection_Connect(&conn, opts);
    if (status != NATS_OK) {
        std::cerr << "Error connecting to NATS Server : " << natsStatus_GetText(status) << std::endl;
        natsOptions_Destory(opts);
        return 1;
    }

    // subscribe for get message
    const char* subject = "example_subject";
    status = natsConnection_Subscribe(&subscription, conn, subject, messageHandler, NULL);
    if (status != NATS_OK) {
        std::cerr << "Error subscribing to subject : " << natsStatus_GetText(status) << std::endl;
        natsConnection_Destroy(conn);
        natsOptions_Destroy(opts);
        return 1;
    }

    // create message object
    const char* subject = "example_subject";
    const char* message = "Hello,";
    status = natsMsg_Create(&msg, subject, NULL, (const void*)mmessage, stelen(message));
    if (status != NATS_OK) {
        std::cerr << "Error Creating NATS message : " << natsStatus_GetText(status) << std::endl;
    } else {
        // publish message
        status = natsConnection_PublishMsg(conn, msg);
        if (status != NATS_OK) {
            std::cerr << "Error publishing message : "
        }

        natsMsg_Destroy(msg);
    }

    // free
    natsSubscription_Destory(subscription);
    natsConnection_Destroy(conn);
    natsOptions_Destroy(opts);

    return 0;
}

publisher가 특정 subject 메시지를 송신하면 해당 subject를 구독하는 subscriber들이 이를 수신하게 된다.

[c++] dynamic_pointer_cast, static_pointer_cast

코드베어 — Sat, 3 Feb 2024 12:15:21 +0900

dynamic_pointer_cast, static_pointer_cast 는 c++에서 스마트 포인터를 다룰때 상/하향 캐스팅을 위해 사용된다. 여기서 상/하향 캐스팅은 자식 클래스에서 부모 클래스로 변환 ( 상향 캐스팅 ), 부모 클래스에서 자식 클래스로 변환 ( 하향 캐스팅 )을 의미한다.

- dynamic_pointer_cast

dynamic_pointer_cast는 런타임에 타입의 안정성을 검사하는 동적 캐스팅을 수행한다. 이는 주로 하향 캐스팅 ( 부모 -> 자식 )에 사용된다.

- static_pointer_cast

static_pointer_cast는 컴파일 타임에 수행하는 정적 캐스팅을 수행한다. 이는 상향 캐스팅( 자식 -> 부모 ), 하향 캐스팅 ( 부모 -> 자식 )에서 모두 쓰일 수 있지만 주로 상향 캐스팅에서 사용된다.

class Base
{
public:
    int a;
    virtual void f() const { std::cout << "I am base!\n"; }
    virtual ~Base() {}
};
 
class Derived : public Base
{
public:
    void f() const override { std::cout << "I am derived!\n"; }
    ~Derived() {}
};

int main()
{
    auto base_ptr = std::make_shared<Base>();
    auto derived_ptr = std::make_shared<Derived>();
    
    auto upcast_ptr = std::static_pointer_cast<Base>(derived_ptr); // 상향 캐스팅
    auto downcast_ptr = std::dynamic_pointer_cast<Derived>(base_ptr); // 하향 캐스팅
}

static_pointer_cast를 사용해 상향 캐스팅 ( Drieved -> Base )를 수행하고 dynamic_pointer_cast를 사용해 하향 캐스팅 ( Base -> Derived )을 하였다.

[c++] std::mutex를 사용하여 공유데이터 동기화 하기

코드베어 — Sat, 3 Feb 2024 12:14:46 +0900

여러 쓰레드에서 공유되는 데이터에 대해 동시에 접근하는 것을 방지하기 위해 std::mutex를 사용할 수 있다.

#include <vector>
#include <mutex>

int g_shared_data = 0;

std::mutex g_mtx;

void IncrementSharedData()
{
    // 스코프 기반 락 관리
    std::lock_guard<std::mutex> lock(g_mtx);
    
    g_shared_data++;
}

int main()
{
    std::vector<std::thread> threads;
    
    // 10개의 쓰레드 생성 및 실행
    for(int i=0; i < 0; i++)
    {
        threads.emplace_back(IncrementSharedData);
    }
    
    // 모든 쓰레드가 종료될때까지 기다림
    for(auto& thr : threads)
    {
        thr.join();
    }
    
    std::cout << "Final value of sharedData is " << sharedData << std::endl;
    
    return 0;
}

std::lock_guard<std::mutex>를 사용하여 스코프 기반으로 동기화 관리를 할 수 있다. 특정 영역을 동기화 처리하려면 g_mtx.lock(), g_mtx.unlock() 함수로 감싸주면 된다.

emplace_back() 함수로 쓰레드 생성과 동시에 실행할 수 있다. 이 때 인자로 쓰레드 함수 (IncrementSharedData)를 넘겨주고 있다.

thr.join() 함수로 쓰레드가 종료될 때까지 대기한다.

[c++] std::function, std::bind 사용하여 Callback 로직 구현하기

코드베어 — Sat, 3 Feb 2024 12:14:19 +0900

c++ 11 이상부터는 std::function, std::bind 사용하여 callback 함수를 묶어 호출하는 패턴을 사용할 수 있다.

class CallbackClass {
public:
    void Callbackfunction(int x) {
        std::cout<< "Callback Func Called :  " << x << std::endl;
    }
}

void CallbackFunction2(int x, int y) {
    std::cout << "Callback Func Called : " << x << std::endl;
}

int main() {
	CallbackClass cls;

    std::function<void(int)> cbMember = std::bind(&CallbackClass::Callbackfunction, &cls, std::placeholders::_1);
    std::function<void(int)> cbFunc = std::bind(&CallbackFunction2, std::placeholders::_1, std::placeholders::_2);
   	
    cbMemeber(1);
    cbFunc(2, 3);
    
    return 0;
}

member 함수를 bind 할 때는 클래스 object(&cls)를 매개변수로 전달해야 하고 std::placeholders::_1은 콜백함수로 전달되는 매개변수를 의미한다.

[c++] 범위 기반 for문 (Range-based for Loop)

코드베어 — Sat, 3 Feb 2024 12:10:58 +0900

범위 기반 for 문은 c++11 부터 도입된 문법으로 컨테이너의 모든 요소를 순회하기 위한 보다 간결하고 읽기 쉬운 방법을 제공한다. 이 구문은 Java의 enhanced for loop과 Python의 for-in loop과 비슷하다. Range-based for Loop은 컨테이너의 시작부터 끝까지 모든 요소를 순회하며 auto를 사용하여 각 요소에 대한 접근을 단순화 한다.

std::map<int, string> employee_map;

employee_map[0] = "Kane";
employee_map[1] = "Jane"
employee_map[2] = "Karr";

for (const auto& pair : employee_map)
{
    auto& no = pair.first;		// key 접근
    auto& name = pair.second;	// value 접근
    
    std::cout << no << "_" << name << std::endl;
}

간단하게 map 데이터를 순회하며 키(first)와 값(second)에 접근하며 출력하는 예제이다. 값을 참조(&)로 접근하여 name 값을 변경하면 원본 데이터도 변경된다. =