Abseil Code Review · 52/79

absl::span 분석

2026년 6월 12일 · Hawk · 2분 읽기

#span이 푸는 문제

배열·벡터·서브 슬라이스를 받는 함수의 시그니처는 모든 입력 형태를 받기 어렵다.

1
// 회피 — 여러 오버로드
2
void Process(const std::vector<int>& v);
3
void Process(const int* p, size_t n);
4
void Process(std::initializer_list<int> il);

absl::Span은 연속 메모리의 view로 이걸 한 줄로 묶는다.

1
#include "absl/types/span.h"
2

3
void Process(absl::Span<const int> s);
4

5
Process(std::vector<int>{1, 2, 3});
6
int arr[] = {1, 2, 3};
7
Process(arr);
8
Process({1, 2, 3});
9
Process(absl::MakeSpan(arr, 2));   // 슬라이스

#std::span과의 관계

C++20 std::span이 표준에 들어왔지만 두 가지 차이가 있다.

측면	`absl::Span`	`std::span`
extent	항상 dynamic (런타임 크기)	static or dynamic
가용성	C++11 이상	C++20 이상
인터페이스	std 호환 (`size`, `data`, `begin/end`)	동일

std::span<int, 5> 같은 static extent는 absl::Span에 없다. fixed-size 배열을 컴파일 타임에 검증하는 용도가 아니면 사실상 같은 도구다.

#생성

absl::MakeSpan 함수 헬퍼가 깔끔하다.

1
std::vector<int> v = {1, 2, 3, 4, 5};
2

3
absl::Span<int> s1 = absl::MakeSpan(v);              // 전체
4
absl::Span<int> s2 = absl::MakeSpan(v.data(), 3);    // 처음 3개
5
absl::Span<int> s3 = absl::MakeSpan(&v[1], 2);       // {2, 3}
6
absl::Span<int> s4(v);                                // 직접 생성
7

8
int arr[10];
9
absl::Span<int> s5(arr);    // sizeof 추론 → size 10

const T 데이터를 받으려면 Span<const T>.

1
void Read(absl::Span<const int> s);   // 읽기 전용
2
void Write(absl::Span<int> s);        // 수정 가능

#슬라이싱

1
absl::Span<int> s = absl::MakeSpan(v);
2

3
auto first3 = s.subspan(0, 3);
4
auto last2  = s.last(2);
5
auto skip1  = s.subspan(1);          // 1번부터 끝까지
6

7
s.front();   // s[0]
8
s.back();    // s[size-1]
9
s.size();    // 원소 개수
10
s.empty();
11
s.data();    // 첫 원소 주소

#컨테이너 인터페이스 호환

absl::Span은 begin()/end()를 제공하므로 range-based for·STL 알고리즘에 그대로 들어간다.

1
void PrintAll(absl::Span<const int> s) {
2
    for (int x : s) std::cout << x << " ";
3
}
4

5
int Sum(absl::Span<const int> s) {
6
    return std::accumulate(s.begin(), s.end(), 0);
7
}

#함수 매개변수 가이드

입력 의도	시그니처
읽기 전용, 어떤 contiguous든	`absl::Span<const T>`
쓰기 가능, 어떤 contiguous든	`absl::Span<T>`
소유권 이양	`std::vector<T>` (값)
컨테이너 타입 강제	구체 타입 (`std::vector<T>`, `std::array<T, N>`)
단일 원소	`const T&`

대부분의 읽기 인터페이스는 Span<const T>로 통일하면 호출 측 boilerplate가 사라진다.

#함정 — dangling

Span은 view 이므로 원본보다 오래 살면 dangle.

1
// 회피 — 임시 객체의 데이터
2
absl::Span<int> Bad() {
3
    std::vector<int> v = {1, 2, 3};
4
    return absl::MakeSpan(v);   // ❌ v 소멸 → dangling
5
}
6

7
// 회피 — initializer_list 임시
8
void Use() {
9
    absl::Span<const int> s = {1, 2, 3};
10
    // ❌ {1,2,3}은 lifetime이 statement 끝 — 다음 줄에서 dangling
11
    Process(s);
12
}
13

14
// Good — 같은 statement 안에서만 사용
15
Process(absl::Span<const int>{1, 2, 3});

string_view와 같은 dangling 위험을 가진다(다음 시리즈의 anti-pattern 참조).

#다차원 — Span<Span> 안 됨

absl::Span은 연속 메모리 가정이다. 행이 흩어진 2D를 직접 표현하지 않는다.

1
// 회피
2
absl::Span<absl::Span<int>> matrix;   // ❌ Span 배열은 연속 메모리 아님 (대부분)
3

4
// Good — flat + stride
5
struct Matrix {
6
    absl::Span<float> data;
7
    int rows, cols;
8
    float& At(int r, int c) { return data[r * cols + c]; }
9
};

다차원이 필요하면 mdspan(C++23) 또는 직접 stride 관리.

#작은 예시 — 청크 처리

1
void ProcessInChunks(absl::Span<const uint8_t> input, size_t chunk_size) {
2
    for (size_t off = 0; off < input.size(); off += chunk_size) {
3
        size_t n = std::min(chunk_size, input.size() - off);
4
        absl::Span<const uint8_t> chunk = input.subspan(off, n);
5
        ProcessChunk(chunk);
6
    }
7
}
8

9
// 호출 측
10
std::vector<uint8_t> buf = ReadFile();
11
ProcessInChunks(absl::MakeSpan(buf), 4096);

원본의 어떤 부분이든 추가 복사 없이 전달.

#회피 패턴

1
// 회피 — vector를 const& 받으면 호출자가 vector 만들어야 함
2
void Sum(const std::vector<int>& v);
3
int arr[] = {1, 2, 3};
4
Sum(std::vector<int>(std::begin(arr), std::end(arr)));   // ❌ 복사
5

6
// Good
7
void Sum(absl::Span<const int> s);
8
Sum(arr);   // 복사 없음

1
// 회피 — Span으로 받았는데 size_t* 추가
2
void Read(absl::Span<const int> s, size_t* count);   // ❌ count는 s.size()
3

4
// Good
5
void Read(absl::Span<const int> s) {
6
    for (int x : s) { /* ... */ }
7
}