C++ OOP(Object-Oriented-Programming) (2)

복사생성자

생성자 : 객체가 생성될 때 실행될 메소드임

복사생성자 : 같은 클래스에 속한 다른 객체를 이용하여 새로운 객체를 초기화 할때 사용

받는 매개변수가 자신이랑 같은 const& 면 복사생성자

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 //header class Vector1{ public : Vector1(); Vector1( const Vector1 & other); private : int mX; int mY; } //cpp Vector1::Vector1() : mX( 0 ) , mY( 0 ) { } Vector1::Vector1( const Vector1 & other) : mX(other.mX); //other는 다른 인스턴스지만 , mY(other.mY); //같은 클래스형이라서 private에 접근가능함 { } Colored by Color Scripter cs

코드에 복사 생성자가 없는 경우, 컴파일러가 암시적 복사생성자 자동생성

cf) 아무런 생성자도 없으면 기본생성자 + 암시적 복사생성자 만들어줌

하나의 생성자라도 유저가 구현했다면 기본생성자는 만들어주지 않음

암시적 복사 생성자

의미와 특징

- 유저가 구현하지 않아서 컴파일러가 만든 복사 생성자를 암시적 복사생성자라 함

- 암시적 복사 생성자는 "얕은 복사"를 함

- 멤버 별 값 복사

- 멤버변수가 객체라면 그 객체의 복사 생성자도 호출됨

- 만약 heap에 동적할당 후 얕은 복사를 진행하면 문제가 발생할 우려가 있음 (아래코드)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 ClassRecord::ClassRecord( const int * scores, int count) : mCount(count) { mScores = new int [mCount]; //동적할당 -> 크기 열어줌 memcpy(mScores, scores, mCount * sizeof ( int )); //복사진행 } ClassRecord::~ClassRecord(){ delete [] mScores; } ClassRecord::ClassRecord( const ClassRecord & other) //암시적 복사생성자와 같음->얕은복사 : mCount(other.mCount) , mScores(other.mScores) // 배열의 시작주소 먹음 { } //main ClassRecord cr(scores, 5 ); //생성자 호출 ClassRecord * crCopy = new ClassRecord(cr); //복사생성자 호출 -> 값만 복사 delete crCopy; //cpCopy의 소멸자 호출 Colored by Color Scripter cs

>>> 메모리 머리속에서 그려보기

-

카피한 객체를 없애는 순간 소멸자가 호출됨

-> 그에 따른 mScores 배열은 없어짐

-> 근데 원본이 여전히 mScores를 가르킴 (문제)

클래스안에서 동적으로 메모리를 할당하고 있다면?

-> 얕은 복사로 인해 위험할 가능성이 높음

-> 직접 복사 생성자를 만들어서 "깊은 복사"를 해야 함

-> 포인터 변수가 가르키는 실제 데이터까지도 복사해야 함(아래코드)

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ClassRecord::ClassRecord( const int * scores, int count) : mCount(count) { mScore = new int [mCount]; //동적할당 -> 크기 열어줌 memcpy(mScores, scores, mCount * sizeof ( int )); //복사진행 } ClassRecord::~ClassRecord(){ delete [] mScores; } ClassRecord::ClassRecord( const ClassRecord & other) //깊은 복사 : mCount(other.mCount) { mScores = new int [other.mCount]; memcpy(mScores, other.scores, mCount * sizeof ( int )); } //main ClassRecord cr(scores, 5 ); //생성자 호출 ClassRecord * crCopy = new ClassRecord(cr); //복사생성자 호출 -> 값만 복사 delete crCopy; //cpCopy의 소멸자 호출 Colored by Color Scripter cs

>>> 자세히 보면, 그냥 오버로딩된 생성자와 비슷함

더보기 연습 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 > > > 아래 헤더파일가지고 깊은 복사 해보기 #pragma once namespace test { class String { public : String( const char * str); String( const String & str); ~String(); void Print(); private : char * mString; size_t mSize; }; } > > > 답 #include < iostream > #include "String.h" using namespace std ; namespace test { String::String( const char * str) : mSize(strlen(str) + 1 ) { mString = new char [mSize]; memcpy(mString, str, mSize); } String::String( const String & str) : mSize(str.mSize) { mString = new char [mSize]; memcpy(mString, str.mString, mSize); } String::~String() { delete [] mString; } void String::Print() { cout < < mString < < endl ; } } > > > 메인사용 #include "String.h" #include < iostream > using namespace std ; int main() { test::String str( "123" ); str.Print(); test::String * str2 = new test::String(str); str2 - > Print(); delete str2; str.Print(); } Colored by Color Scripter cs

연산자 오버로딩

함수오버로딩

- 매개변수 목록을 제외하고 모든 게 동일

- 반환형은 달라도 괜찮음

- 근데 매개변수가 같은데 반환형이 다르면 컴파일에러 -> 중복문제

- 매칭되는 것이 하나여야함

- 자료형이 float -> int 가능함 (표준변환)

(C언어 캐스팅): https://dojang.io/mod/page/view.php?id=493

함수 오버로딩 매칭하기

1) void Print(int score);

2) void Print(const char* name);

3) void Print(float gpa, const char* name);

4) int Print(int score); //컴파일 에러 -> 1번과 매칭됨

5) int Print(float gpa);

1) void Print(int score);

2) void Print(const char* name);

3) void Print(float gpa, const char* name);

Print(100); // 1

Print("Pope")l // 2

Print(4.0f, "Pope"); // 3

Print(77.5f); // 1 컴파일 경고가 나올 수 있음

Print("Pope", 4.0f); //컴파일에러

1) void Max(double, double)

2) void Max(int, int)

max(1, 3.14)

>>> 표준변환 1개, 정확한타입 1개 >>> 모호한 호출임 >>> 컴파일에러

>>> 그냥 형변환해서 둘 이상 들어갈 수 있으면 컴파일에러임

cf) 3.14f == float | 3.14 == double

연산자 오버로딩(operator overloading)

단항연산자 : 피연산자 1개

이항연산자 : 피연산자 2개

- C++에서는 연산자 오버로딩을 지원함 (C, Java는 없음)

- 연산자를 오버로딩 하는 방법은 두가지

1) 멤버 함수로 : (클래스 + 연산자 + 매개변수 | ex. Vector1 + Vector1 )

2) 전역 함수로 : (매개변수1 + 연산자 + 매개변수2) | ex. cout << Vector )

-> 좌항이 접근할 수 없는 int형이나 os객체일 때 사용함

- 특정 연산자들은 멤버 함수를 이용해서만 오버로딩 가능

-> =, (), [], -> 등등

1) 멤버 함수로 연산자 오버로딩

- Vector끼리의 연산을 진행하고 싶음

ex) Vector vec = Vector1 + Vector2;

- 멤버 구현쪽으로 가서 연산자 오버로딩 진행

1 2 3 4 5 6 7 Vector1 Vector1:: operator + ( const Vector1 & rhs) { Vector1 retVec; retVec.mX = mX + rhs.mX; retVec.mY = mY + rhs.mY; return retVec; } Colored by Color Scripter cs

1 2 3 4 5 6 7 8 9 10 11 12 #include < iostream > #include "Vector1.h" using namespace std ; int main() { Vector1 vec1( 1 , 1 ); Vector1 vec2( 2 , 2 ); Vector1 vec = vec1 + vec2; cout < < vec.GetX() < < ", " < < vec.GetY(); //3, 3 } Colored by Color Scripter cs

2) 전역 함수로 연산자 오버로딩

- cout << Vector1; 하면 (10, 20)처럼 만들고 싶음 (ex. toString())

- cout에 들어가서 바꾸는 것은 불가능

-> 전역 함수를 만들어 연산자 오버로딩해야 함

-> 전역 함수는 private멤버에 접근할 수 없으므로 friend 키워드 필요

friend

- 클래스 정의 안에 friend 키워드 사용가능

-> 다른 클래스나 함수가 나의 private 또는 protected 멤버에 접근할 수 있게 허용

- friend 클래스

1 2 3 4 5 6 class X{ friend class Y; private : int mPrivateInt; }; // class Y에서 mPrivateInt 접근 가능 해짐 cs

- friend 함수

1 2 3 4 5 6 7 class X{ friend class Y; friend void Foo( const X & x); private : int mPrivateInt; }; // Foo()에서 mPrivateInt 접근 가능 해짐 cs

- cout << Vector1; 를 위한 구현

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //header class Vector1{ friend std ::ostream& operator < < ( std ::ostream & os, const Vector1 & rhs); public : private : int mX; int mY; }; //cpp std ::ostream& Vector1:: operator < < ( std ::ostream & os, const Vector1 & rhs){ os < < rhs.mX < < ", " < < rhs.mY; return os } Colored by Color Scripter cs

cf) 리턴자료형이 ostream& 인 것은 출력의 체이닝을 위함

-> os << Vector1 << endl;

-> 위의 예에서 os << Vector1 이 void라면 void << endl; 은 진행할 수 없음

-> 그래서 os를 반환함

cf) 좌항의 매개변수를 const로 하지 않은 이유는 읽기 전용으로 사용하지 않아서

-> 출력의 상태를 바꿔 버릴수도 있기 때문

cf) friend함수를 작성해야 class 구현부에서 작성하는 전역함수를 main에서 사용할 수 있음

cf) 만약 하지 않으면 컴파일에러

cf) friend함수를 작성하면 외부에서 Vector1:: 로 접근해야함 (11줄 참고)

(정리)전역함수로 연산자오버로딩을 위해서는

header파일에 전역함수를 friend키워드 사용or전역함수선언 -> 하지않으면 main쪽에서 찾지를 못함

1) header에 전역함수를 class멤버말고 전역으로 선언만 -> cpp에서 정의구현

2) header에 friend키워드 사용 -> cpp에서 정의구현

3) main에 사용

연산자 오버로딩과 const

const를 쓰는 이유? (차후 포스팅)

- 멤버 변수의 값이 바뀌는 것을 방지

- 최대한 많은 곳에 const를 붙일 것

-> 일단 const를 붙여서 사용 -> 에러면 바꿔라

- 지역변수(매개변수)에도 마찬가지

const& 를 쓰는 이유?

- 멤버변수가 바뀌고(const) 불필요한 객체의 사본이 생기는 것을 방지(&)

const를 언제 안쓸까?

- 오브젝트의 상태변경이 있을 때 (스트림도 마찬가지)

연산자 오버로딩 제한사항

1. 오버로딩된 연산자는 최소한 하나의 사용자정의 형을 가져야 함

2. 오버로딩된 연산자는 피연산자 수를 동일하게 유지해야 함

3. 새로운 연산자 부호를 만들 수 없음

4. 오버로딩할 수 없는 연산자 존재(. .* :: ?:)

연산자 오버로딩을 남용하지 말 것

- 직관적인 상황에서만 사용하고 직관적이지 못하면 그냥 함수 만들어라

대입 연산자

operator=

- 복사 생성자와 거의 동일 (초기화와 대입의 차이)

-> 복사 생성자는 생성당시에만 호출함

-> (String myStr = originStr : 이것도 복사생성자로 가져감, 선언 후 myStr = originStr으로 호출함)

-> 그래서 대입 연산자는 내가 힙에 가진 메모리를 해제해 줄 필요가 있을 수도

-> 자신이 원래 들고 있던 heap영역 메모리를 해제해야 하기 때문

ex)

MyString a("chararray"); //생성자 호출

MyString b("asdf");

a = b; // 대입연산자 + a가 가지고 있던 heap영역 메모리 해제

- 복사 생성자를 구현했다면 대입 연산자도 구현해야 좋음

-> 하는일이 비슷하니까!

암시적 operator=

- 컴파일러가 자동으로 만들어 줌

- 근데 얕은 대입임

-> 깊은 복사해야 함

암시적 함수

- 암시적 기본 생성자 : 아무런 생성자가 없으면 컴파일러가 만듦

- 암시적 복사 생성자 : 아무런 복사 생성자가 없으면 컴파일러가 만듦(얕은 복사)

- 암시적 소멸자 : 아무런 소멸자가 없으면 컴파일러가 만듦

- 암시적 대입 연산자 : 아무런 소멸자가 없으면 컴파일러가 만듦(얕은 복사)

암시적 함수를 제거하는 법(전통적...)

-암시적 기본 생성자 -> private에 넣어버림, 다른 생성자 구현

-암시적 복사 생성자 -> private에 넣어버림

-암시적 소멸자 -> private에 넣어버림

-암시적 대입 연산자 -> private에 넣어버림

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 #include < iostream > #include < cstring > #include "Tmp.h" namespace test1 { String::String( const char * str) //"123" : mSize(strlen(str) + 1 ) //"123" + 1 { mString = new char [mSize]; memcpy(mString, str, mSize); } String::String( const String & other) : mSize(other.mSize) { std :: cout < < "call copy structor" < < std :: endl ; mString = new char [mSize]; memcpy(mString, other.mString, mSize); } String::~String() { delete [] mString; } void String::Print() { std :: cout < < mString < < std :: endl ; } void String:: operator = ( const String & rhs) { std :: cout < < "call operator=" < < std :: endl ; mSize = rhs.mSize; delete [] mString; mString = new char [mSize]; memcpy(mString, rhs.mString, mSize); } } Colored by Color Scripter cs

===참고===

Q) 레퍼런스에 대해서 (반환, 매개변수 등등)

Q) const에 대해서 자세히

현재까지 객체지향

- 생성자 오버로딩

- 복사생성자 오버로딩

- 대입연산자 오버로딩

- 소멸자 구현 (가상소멸자)

- 전역함수로 연산자오버로딩해보기

아래 해더파일로 놀아보기

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 #pragma once class Test { //friend std::ostream& operator<<(std::ostream& os, const Test& rhs); public : Test( const char * str); Test( const Test & str); virtual ~Test(); void operator = ( const Test & rhs); void Print(); private : char * mTest; size_t mSize; }; std ::ostream & operator < < ( std ::ostream & os, const Test & rhs); cs

from http://malbongcode.tistory.com/56 by ccl(S) rewrite - 2020-03-25 15:54:09