개인적으로는 잘 사용하지 않음
연산자 오버로딩 종류
EX
class Vector
{
public:
Vector operator+(const Vector& rhs) const;
};
Vector Vector::operator+(const Vector& rhs) const
{
Vector sum;
sum.mX = mX + rhs.mX;
sum.mY = mY + rhs.mY;
return sum;
}
Vector sum = v1 + v2;
//'v1' : 좌항
//'v2' : 우항
Vector sum = v1 + v2;
Vector sum = v1.operator+(v2);
std::cout << number;
std::cout.operator<<(number);
연산자 오버로딩 하는 방법
멤버 함수를 통해서만 오버로딩 가능 한것
operator 치환 과정
Vector result = vec1 + vec2;
|
V
Vector result = vec1.operator+(vec2)
|
V
[반환형] result = vec1.함수이름(인자);
|
V
Vector Vector::operator+(const Vector& rhs) const;
// mX, mY 는 private이라서 접근 불가능
std::cout << vector1.mX << ", " << vector1.mY << std::endl;
// 모든 멤버에 Getter를 구현해주어야 하나, 귀찮다. cout 쓰기도 번거롭다
std::cout << vector1.GetX() << ", " << vector1.GetY() << std::endl;
//이렇게 하고 싶다!!
std::cout << vector1;
/*
'<<' 를 연산자 오버로딩 하기 위해서는 다음 함수를
cout 클래스에 멤버 함수로 추가해야 하는데...
그러나 어떻게 하지 cout 은 내가 수정할 수 있는 코드가 아닌데
[cout.h]
void cout::operator<<(cconst Vector& rhs) const
{
A
|
cout 클래스에 다음 멤버함수 추가 가능??? ... X
}
*/
void operator<<(std::ostream& os, const Vector& rhs)
{
os << rhs.mX <<", " << rhs.mY
}
class X
{
friend void Foo(X& x);
private:
int mPrivateInt;
};
void Foo(X& x) // 전역 함수
{
x.mPrivateInt += 10;
}
// [Vector.h]
class Vector
{
// 지정자에 상관 없다, 어차피 frined로 모두 접근 가능할 텐데
// 주로 클래스 상단에 위치 시킨다.
// Vector에 operator를 지정
friend void operator<<(std::ostream& os, const Vector& rhs);
};
// [Vector.cpp]
void operator<<(std::ostream& os, const Vector& rhs) const
{
// friend로 지정 되었기 때문에 private 멤버에 접근 가능
os << rhs.mX << ", " << rhs.mY;
}
Vector vector1(10, 20);
std::cout << vector1;
std::cout << vector1 << endl;
// std::cout << vector1 에 대한 반환형이 없어서
// << endl 구문에서 컴파일 에러가 발생 한다.
// << endl 문제 처리하기 위해서는 반환형 처리 필요
std::ostream& operator<<(std::ostream& os, const Vector& rhs)
{
os << rhs.mX << ", " << rhs.mY;
return os; //뒤에 올 녀석들도 출력하게 하기 위해 반환
}
//std::ostream& os 는 const가 아니다, ostream의 operator<<() 함수가 const 함수가 아니기 때문에...
// 때문에 반환값 std::ostream& 도 const가 아니다.
비 멤버함수에는 const를 사용할 수 없다.
const를 쓰는 이유?
Vector operator+(const Vector& rhs) const;
const&를 사용하는 이유?
Vector operator+(const Vector& rhs) const;
vector1 += vector2
vector1 = vector1.operator+=(vector2);
Vector& operator+=(const Vector& rhs);
class Vector {
public:
int m_x;
Vector& operator+=(const Vector& rhs) {
m_x = m_x + rhs.m_x;
return *this;//참조 반환할 때는 이렇게 넘긴다.
}
};
int main() {
Vector vec1;
vec1.m_x = 1;
Vector vec2;
vec2.m_x = 2;
Vector vec3;
vec3.m_x = 3;
vec1 += vec2 += vec3;//chaining
std::cout << vec1.m_x << std::endl;
return 0;
}
const Vector& operator+=(Vector& rhs)
vector1 += vector2 += vector3
// vector2 += vector3 연산하고 반환한 것이 const Vector&인데
// vector1에서 받는 인자 타입은 Vector& rhs 로 받으니 에러가 발생해서 chaining을 못 한다.
MyString a = b;//복사 생성자
a = c;// 이때 a가 가지고 있던 메모리를 해제해주어서 c에 대한 deep copy를 해주어야 한다.
Vector& operator=(const Vector& rhs)
{
mX = rhs.mX;
mY = rhs.mY;
return *this;// 자기 자신을 넘겨야 chaining이 가능
}
Vector vector = vec1 << vec2;
Vector vector = vec1 * vec2;
CrossProduct(vec1);
, HadamardProduct(vec1);