C++ Object Slicing | "객체 슬라이싱" 가이드

Object Slicing이란?

파생 클래스 객체를 값(value)으로 기본 클래스에 넣을 때, 객체 메모리 상에서 “기본 클래스 부분만” 복사되고 Derived에만 있던 멤버·다형성 정보가 잘려 나가는 현상입니다. 이름 그대로 빵 한 덩어리를 도마로 “슬라이스”한 것과 비슷합니다.

메모리 관점에서 왜 일어나는가

Base b = d;에서 대입의 왼쪽 타입이 Base이므로, 컴파일러는 Base 크기만큼의 저장 공간만 준비합니다. 오른쪽 d는 Derived 전체를 담고 있어도, 대입 연산은 Base 서브객체만 복사합니다. 그 결과 Derived에만 있던 필드(아래 예에서는 y)는 대상 객체 b 안에 자리가 없어서 사라집니다.

class Base {
    int x;   // Base 레이아웃의 일부
};

class Derived : public Base {
    int y;   // Derived가 Base 뒤에 “붙어 있는” 추가 멤버
};

Derived d;
d.x = 1;
d.y = 2;

Base b = d;  // b에는 x≈1만 의미 있게 복사되고, y는 잘림(슬라이싱)
// b의 타입이 Base이므로 b.y 같은 접근 자체가 불가능

가상 함수가 기대대로 안 도는 이유도 같은 계열입니다. 값으로 넘기면 실제 객체는 Base 크기의 복사본이 되어, Dog였던 정보가 잘리면 speak()도 기본 클래스 쪽 동작으로 고정되는 식입니다(아래 예시 1 참고).

발생 원인

// 1. 값으로 전달
void func(Base b) {  // 슬라이싱
    // ...
}
Derived d;
func(d);

// 2. 값으로 반환
Base func() {
    Derived d;
    return d;  // 슬라이싱
}

// 3. 컨테이너
std::vector<Base> vec;
Derived d;
vec.push_back(d);  // 슬라이싱

실전 예시

예시 1: 문제 상황

class Animal {
public:
    virtual void speak() {
        std::cout << "Animal" << std::endl;
    }
};

class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Woof!" << std::endl;
    }
};

void makeSpeak(Animal a) {  // 값으로 전달
    a.speak();  // 항상 "Animal" 출력
}

int main() {
    Dog d;
    makeSpeak(d);  // "Animal" (슬라이싱)
}

예시 2: 올바른 해결

// ✅ 레퍼런스 사용
void makeSpeak(Animal& a) {
    a.speak();  // 다형성 작동
}

// ✅ 포인터 사용
void makeSpeak(Animal* a) {
    a->speak();  // 다형성 작동
}

int main() {
    Dog d;
    makeSpeak(d);  // "Woof!"
    makeSpeak(&d); // "Woof!"
}

예시 3: 컨테이너

// ❌ 값 컨테이너
std::vector<Animal> animals;
Dog d;
animals.push_back(d);  // 슬라이싱
animals[0].speak();    // "Animal"

// ✅ 포인터 컨테이너
std::vector<Animal*> animals;
Dog* d = new Dog();
animals.push_back(d);
animals[0]->speak();   // "Woof!"

// ✅ 스마트 포인터
std::vector<std::unique_ptr<Animal>> animals;
animals.push_back(std::make_unique<Dog>());
animals[0]->speak();   // "Woof!"

예시 4: 복사 방지

class Base {
public:
    virtual ~Base() = default;
    
    // 복사 방지
    Base(const Base&) = delete;
    Base& operator=(const Base&) = delete;
    
    // 이동은 허용
    Base(Base&&) = default;
    Base& operator=(Base&&) = default;
    
protected:
    Base() = default;
};

자주 발생하는 문제

문제 1: 값 전달

// ❌ 값 전달
void process(Base obj) {
    obj.virtualFunc();  // 슬라이싱
}

// ✅ 레퍼런스 전달
void process(const Base& obj) {
    obj.virtualFunc();  // 다형성
}

문제 2: 값 반환

// ❌ 값 반환
Base create() {
    return Derived();  // 슬라이싱
}

// ✅ 포인터 반환
std::unique_ptr<Base> create() {
    return std::make_unique<Derived>();
}

문제 3: 대입 연산자

Derived d;
Base b;
b = d;  // 슬라이싱

// ✅ 포인터 사용
Base* b = &d;  // 다형성 유지

문제 4: 컨테이너 저장

// ❌ 값 저장
std::vector<Base> vec;
vec.push_back(Derived());  // 슬라이싱

// ✅ 스마트 포인터
std::vector<std::unique_ptr<Base>> vec;
vec.push_back(std::make_unique<Derived>());

탐지 방법

// 컴파일러 경고
g++ -Weffc++ program.cpp

// 복사 생성자 삭제
class Base {
public:
    Base() = default;
    Base(const Base&) = delete;  // 슬라이싱 방지
};

FAQ

Q1: Object Slicing은 언제?

A: 파생 클래스를 기본 클래스 값으로 복사 시.

Q2: 해결 방법은?

A:

• 레퍼런스 사용
• 포인터 사용
• 스마트 포인터

Q3: 탐지는?

A:

• 컴파일러 경고
• 복사 생성자 삭제

Q4: 성능 영향?

A: 레퍼런스/포인터는 영향 없음.

Q5: 컨테이너는?

A: 스마트 포인터 컨테이너 사용.

Q6: Object Slicing 학습 리소스는?

A:

• “Effective C++”
• “C++ Primer”
• “More Effective C++“

---

같이 보면 좋은 글 (내부 링크)

이 주제와 연결되는 다른 글입니다.

• C++ 상속과 다형성 | “virtual 함수” 완벽 가이드
• C++ 가상 함수 | “Virtual Functions” 가이드
• C++ 스마트 포인터 | unique_ptr/shared_ptr “메모리 안전” 가이드

관련 글

• C++ 가상 함수 |
• C++ CRTP 패턴 |
• C++ CRTP 완벽 가이드 | 정적 다형성과 컴파일 타임 최적화
• C++ Decorator Pattern 완벽 가이드 | 기능 동적 추가와 조합
• C++ 가상 소멸자 |