TIL: Explicit과 Mutable

📅 2026-04-06
이번주 부터 오전에는 C++공부 오후에는 언리얼 및 블루프린트 공부 할 예정
해당 글은 언리얼 블루프린트 TIL에 링크로 삽입됩니다.

미리 만들어놓은 MyString class를 기반으로 설명 진행됨.

#include<iostream>

class MyString
{
    char* string_content;
    int string_length;
    
    int memory_capacity;
public:
    MyString(int capacity);
    
    MyString(const char* str);
    
    MyString(const MyString& str);
    
    ~MyString();
    
    int length() const;
    
};

MyString::MyString(int capacity)
{
    string_content = new char[capacity];
    string_length = 0;
    memory_capacity = capacity;
    
    std::cout << "Capacity: " << capacity << std::endl;
}


MyString::MyString(const char* str)
{
    string_length = 0;
    while ( str[string_length++])
    {
        
    }
    
    string_content = new char[string_length];
    memory_capacity = string_length;
    
    for (int i = 0; i != string_length; i++) string_content[i] = str[i];
}


MyString::MyString(const MyString& str)
{
    string_length = str.string_length;
    string_content = new char[string_length];
    
    for (int i = 0; i != string_length; i++) string_content[i] = str.string_content[i];
}

MyString::~MyString()
{
    delete[] string_content;
}

int MyString::length() const
{
    return string_length;
}

Explicit

int main()
{
	 // 예를들어 MyString타입을 인자로 받는 함수 SomethingToDoString()이 있다면
    
    SomethingToDoString(MyString("abc")); // 동작O
    SomethingToDoString("abc"); //동작O
    
    // "abc" C++컴파일러는 이 문자열 "abc"를 어떻게하면 MyString으로 변환 할 수 있을지 생각함. 
    // 그리고 MyString 생성자 중에서는 MyString(const char* str)가 있어서 암시적 변환(implicit conversion)을 함
    SomethingToDoString("abc") -> SomethingToDoString(MyString("abc"));
}

이런 암시적 변환을 하지 않도록 컴파일러에게 명시해줄 수 있는 키워드가 explicit이다.

처음에 작성한 MyString 클래스에서 수정을 해보자.

class MyString
{
    char* string_content;
    int string_length;
    
    int memory_capacity;
public:
    MyString(int capacity);
    
    explicit MyString(const char* str); // 수정
    
    MyString(const MyString& str);
    
    ~MyString();
    
    int length() const;
    
};

...

int main()
{
	SomethingToDoString("abc"); // 컴파일 에러
}

또한 explicit은 복사 생성자 호출도 막을 수 있다.

MyString s("abc"); // 허용
MyString s = "abc"; // 컴파일 에러

Mutable

#include <iostream>

class A
{
    int data_;
    
public:
    A(int data) : data_(data) {}
    void DoSomething(int x) const
    {
        data_ = x;
    }
    
    void PrintData() const
    {
        std::cout << data_ << std::endl;
    }
};
int main(int argc, char* argv[])
{
    A a(10);
    a.DoSomething(3);
    a.PrintData();
    return 0;
}

위 코드는 void DoSomething > data_ = x; 에서 에러가 발생한다.

하지만 int data_를 mutable로 선언한다면 어떨까?

class A
{
    mutable int data_;
    
public:
    A(int data) : data_(data) {}
    void DoSomething(int x) const
    {
        data_ = x;
    }
    
    void PrintData() const
    {
        std::cout << data_ << std::endl;
    }
};
int main(int argc, char* argv[])
{
    A a(10);
    a.DoSomething(3);
    a.PrintData();
    return 0;
}

3이 잘 출력되는걸 볼 수 있다.

여기서 그럼 이런 질문이 생길 수 있다.

mutable을 쓸거면 차라리 DoSomething에서 const를 빼면 되지 않나?

mutable을 왜 써야할까?

멤버함수를 왜 const로 선언하는지 먼저 생각해봐야하는데
클래스 멤버 함수들은 이 오브젝트가 어떤 일을 할 수 있는지를 나타내고 있다.

멤버함수를 const로 선언하는 의미는

이 함수는 객체의 내부 상태에 영향을 주지 않는다.

대표적인 예로 읽기 작업을 수행하는 함수들을 들 수 있다.

class Server
{
    // ... 생략 ...
    
    Cache cache;
    
    User GetUserInfo(const int user_id) const
    {
        // 캐시에서 user_id 검색
        Data user_data = cache.find(user_id);
        
        // 만약 캐시에 데이터가 없다면 데이터베이스에 요청
        if (!user_data)
        {
            user_data = Database.find(user_id);
            
            // 이후 캐시에 user_data 등록
            cache.update(user_id, user_data); // 컴파일 에러 > const 함수이기 때문에 변수변경 불가능
        }
        
        // 리턴된 정보로 User 객체 생성
        return User(user_data);
    }
};

GetUserInfo가 const 함수이기 때문에 캐시 업데이트가 불가능하다.

하지만 Cache를 mutable로 선언하게 되면 수정할 수 있게 된다.