[언리얼5] 언리얼 CPP 연산자 오버로딩

언리얼 CPP에서 연산자 오버로딩을 활용하면 클래스를 더 직관적으로 사용 할 수 있습니다.

연산자 오버로딩은 클래스나 구조체에서 특정 연산자를 정의하여 객체 간의 연산이 가능합니다.

기본 연산자 오버로딩의 종류

• 대입 연산자 (=)
• 산술 연산자 (+, -, *, /, %)
• 비교 연산자 (==, !=, <, >, <=, >=)
• 논리 연산자 (&&, ||, !)
• 비트 연산자 (&, |, ^, ~, <<, >>)
• 증감 연산자 (++, --)
• 배열 인덱스 연산자 ([])
• 함수 호출 연산자 (())
• 포인터 연산자 (*, ->)

사용 예시

1. 대입 연산자 (=)
대입 연산자는 객체를 다른 객체에 복사할 때 사용됩니다.

class MyClass {
public:
    int Value;

    MyClass& operator=(const MyClass& Other) {
        if (this == &Other) return *this;
        Value = Other.Value;
        return *this;
    }
};

 

2. 산술 연산자 (+, -)
산술 연산자는 객체 간의 수학적 연산을 정의합니다.

class Vector2D {
public:
    float X, Y;

    Vector2D operator+(const Vector2D& Other) const {
        return Vector2D{ X + Other.X, Y + Other.Y };
    }

    Vector2D operator-(const Vector2D& Other) const {
        return Vector2D{ X - Other.X, Y - Other.Y };
    }
};

 

3. 비교 연산자 (==, !=)
비교 연산자는 객체가 같은지 비교합니다.

class FName {
public:
    FString Name;

    bool operator==(const FName& Other) const {
        return Name == Other.Name;
    }

    bool operator!=(const FName& Other) const {
        return !(*this == Other);
    }
};

 

4. 배열 인덱스 연산자 ([])
배열 인덱스 연산자는 객체를 배열처럼 사용할 수 있게 합니다.

class MyArray {
private:
    TArray<int32> Data;

public:
    int32& operator[](int32 Index) {
        return Data[Index];
    }

    const int32& operator[](int32 Index) const {
        return Data[Index];
    }
};

 

언리얼 엔진에서의 특별한 연산자 오버로딩 예시

FVector의 산술 연산자 오버로딩
언리얼 엔진의 FVector 클래스는 여러 산술 연산자를 오버로딩하여 벡터 간의 연산을 쉽게 할 수 있습니다.

FVector operator+(const FVector& V) const
{
    return FVector(X + V.X, Y + V.Y, Z + V.Z);
}

FVector operator-(const FVector& V) const
{
    return FVector(X - V.X, Y - V.Y, Z - V.Z);
}

FVector A(1.0f, 2.0f, 3.0f);
FVector B(4.0f, 5.0f, 6.0f);

FVector Sum = A + B; // FVector(5.0f, 7.0f, 9.0f)
FVector Diff = A - B; // FVector(-3.0f, -3.0f, -3.0f)

 

FName의 비교 연산자 오버로딩
FName 클래스는 이름 비교를 위해 ==와 != 연산자를 오버로딩합니다.

bool operator==(const FName& Other) const
{
    return ComparisonIndex == Other.ComparisonIndex && Number == Other.Number;
}

FName Name1(TEXT("Player1"));
FName Name2(TEXT("Player2"));

if (Name1 == Name2) {
    UE_LOG(LogTemp, Warning, TEXT("Names are equal"));
} else {
    UE_LOG(LogTemp, Warning, TEXT("Names are not equal"));
}

 

FColor 클래스의 연산자 오버로딩
FColor 클래스는 색상 관련 연산을 위해 연산자가 오버로딩되어 있습니다.

FColor operator*(float Scalar) const
{
    return FColor(
        FMath::Clamp<int32>(R * Scalar, 0, 255),
        FMath::Clamp<int32>(G * Scalar, 0, 255),
        FMath::Clamp<int32>(B * Scalar, 0, 255),
        A
    );
}

FColor Color(100, 150, 200, 255);
float Scalar = 0.5f;

FColor NewColor = Color * Scalar; // NewColor는 FColor(50, 75, 100, 255)

 

FMatrix 클래스의 곱셈 연산자 오버로딩
FMatrix 클래스는 행렬 곱셈을 위해 연산자가 오버로딩되어 있습니다.

FMatrix operator*(const FMatrix& Other) const
{
    FMatrix Result;
    for (int32 Row = 0; Row < 4; ++Row)
    {
        for (int32 Col = 0; Col < 4; ++Col)
        {
            Result.M[Row][Col] = 
                M[Row][0] * Other.M[0][Col] + 
                M[Row][1] * Other.M[1][Col] + 
                M[Row][2] * Other.M[2][Col] + 
                M[Row][3] * Other.M[3][Col];
        }
    }
    return Result;
}

FMatrix Matrix1 = FMatrix::Identity;
FMatrix Matrix2 = FMatrix::Identity;

FMatrix Result = Matrix1 * Matrix2; // Result는 여전히 단위 행렬

 

연산자 오버로딩을 통하여 클래스와 구조체를 더 직관적이고 사용하기 쉽게 만들 수 있습니다.