#include <iostream>
/*
1. &연산자도 사용자가 만들 수 있다.
2. &연산자를만들 때는 상수 함수로 만들어야 한다.
*/
using namespace std;
class Point {
int x = 0, y = 0;
public:
const Point* operator&() {
cout << "operator " << endl;
return 0;
}
};
int main() {
Point p;
cout << &p << endl; // compiler는 보통 연산자를 p.operator&() 형태로 해석 함. 그런데 & 정의가 없음. 왜 동작 함 ?
// 컴파일러가 그냥 객체의 메모리를 찍는 것임.
const Point p2; // const를 붙이면 ? 상수객체는 상수 함수만 부를 수 있음.
// & 오버로드에 const를 붙이지않으면, &에 대한 디폴트 연산자가 불림.
cout << &p2 << endl; // operator
}
#include <iostream>
/*
1. &연산자도 사용자가 만들 수 있다.
2. &연산자를만들 때는 상수 함수로 만들어야 한다.
*/
using namespace std;
class Point {
int x = 0, y = 0;
ㅁ
public:
Point* const operator&() {
cout << "operator " << endl;
return 0;
}
Point* const showAddress() {
cout << "operator " << endl;
return this;
}
};
int main() {
Point pt;
Point *p = &pt; // 그대로 두면 그냥 0이 나온다.
// pt가 포인터로 보이기 때문에 &연산자 오보로드가 불리는 것.
// 1. pt가 포인터가 아닌 타입으로 불리게 해야 한다.
// &(static_cast<char>(pt)); // error발생 함. 관련 없는 타입 캐스팅 실패.
// 2. reinterpret
// char * p1 = &(reinterpret_cast<char>(pt)); // 안됨. 아무리 reinterpret_cast라도 서로다른 타입은 캐스트 안됨. 또한 임시객체 생성 됨.
// 메모리에 pt가 있음. 값으로 캐스팅 하면, 새로 캐릭터 메모리를 새로 만듬. 그리고 기존 메모리의 값을 복사 함. 즉, 임시객체의 주소를 넘겨 받음.
// 서로 다른 타입의 값으로 캐스팅 할 수 없지만, 참조 캐스팅은 가능.
char * p1 = &(reinterpret_cast<char&>(pt));
cout << (void*)p1 << endl;
cout << pt.showAddress() << endl;
// pt2가 상수 객체라면, 또 변경 해야 함.
const Point pt2;
char * p2 = const_cast<char*>(&(reinterpret_cast<const char&>(pt2))); // const_cast : const를 제거 함
cout << (void*)p2 << endl;
cout << pt2.showAddress() << endl;
const Point pt3;
Point * p3 = reinteroret_cast<Point *>(const_cast<char*>(&(reinterpret_cast<const char&>(pt2)))); // const_cast : const를 제거 함
cout << (void*)p3 << endl;
cout << pt3.showAddress() << endl;
}
#include <iostream>
/*
1. &연산자도 사용자가 만들 수 있다.
2. &연산자를만들 때는 상수 함수로 만들어야 한다.
*/
using namespace std;
class Point {
int x = 0, y = 0;
public:
Point* const operator&() {
cout << "operator " << endl;
return 0;
}
Point* const showAddress() {
cout << "operator " << endl;
return this;
}
};
template <typename T> T* xaddressof(const T& obj) {
return reinterpret_cast<T *>(const_cast<char*>(&(reinterpret_cast<const char&>(obj))));
}
int main() {
const Point pt3;
Point * p3 = xaddressof(pt3);
cout << p3 << endl;
//
cout << pt3.showAddress() << endl;
cout << addressof(pt3) << endl; // VC++의 addressof는 비상수 객체만 가능.
}
#include <iostream>
using namespace std;
struct Base
{
int value = 10;
void print_address() const { cout << this << endl; }
};
struct Derived : public Base {
int value = 20;
};
int main() {
Derived d;
cout << d.value << endl; // 20
cout << static_cast<Base>(d).value << endl;
// 값 캐스팅은 새로 메모리를 할당하고 거기에 복사가 발생 함 !
cout << &d << endl;
cout << &(static_cast<Base>(d)) << endl; // g++에서는 컴파일 안됨. 임시객체는 주소를 출력 할 수 없다가 c++ 규칙.
// 임시객체의 주소를 출력하려면, 직접은 안되고, 멤버 함수를 통해서 가능하다.
// print_address 멤버를 하나 정의해 줌.
static_cast<Base>(d).print_address();
static_cast<Base&>(d).print_address();
}
#include <iostream>
using namespace std;
class Car {
int mCount=0;
public:
~Car() { cout << "~car" << endl; }
void incStrong() { ++mCount; }
void decStrong() { if (--mCount == 0) delete this; }
};
Car *pObj;
int main() {
Car *p = new Car;
p->incStrong();
pObj = p; // 전역 변수에 저장
pObj->incStrong();
//delete p; // pObj는 없어진 주소를 가지고 있게 됨. 그래서 사용하는 방법이 참조개수 관리하는 방법이 있음.
p->decStrong();
p->decStrong(); // 참조계수가 0이므로 이때 파괴 됨.
}
#include <iostream>
using namespace std;
class RefBase {
int mCount = 0;
public:
virtual ~RefBase() { cout << "~base" << endl; }
void incStrong() { ++mCount; }
void decStrong() { if (--mCount == 0) delete this; }
};
class Truck : public RefBase{
~Truck() { cout << "~tr" << endl; }
};
int main() {
// 기반 클래스의 소멸자가 가상이어야 기반 클래스에서 delete this를 부를 때 가상 함수 테이블을 따라서 가서 자식의 소멸자를 부르게됨.
// 버추얼이 아니면 자식 소멸자 안불림.
// c++진영에서는 버추얼을 싫어 함. 버추얼 테이블 오버헤드가 있음.
}
#include <iostream>
using namespace std;
class RefBase {
int mCount = 0;
public:
~RefBase() { cout << "~base" << endl; }
void incStrong() { ++mCount; }
void decStrong() { if (--mCount == 0) delete this; } // 자식의 객체를 없애기 위해서는 자식 타입으로 캐스트 필요 함.
// 그를 위해서 CRTP를 쓸 수 있음.
};
class Truck : public RefBase {
~Truck() { cout << "~tr" << endl; }
};
int main() {
// 기반 클래스의 소멸자가 가상이어야 기반 클래스에서 delete this를 부를 때 가상 함수 테이블을 따라서 가서 자식의 소멸자를 부르게됨.
// c++진영에서는 버추얼을 싫어 함. 버추얼 테이블 오버헤드가 있음.
}
#include <iostream>
using namespace std;
template <typename T>
class RefBase {
mutable int mCount = 0;
public:
~RefBase() { cout << "~base" << endl; }
void foo() { this } // RefBase * this.
void goo() const { this } // const RefBase * this. // 상수 함수라서 그 안의 변수도 모두 상수로 처리 된다.
void incStrong() const { ++mCount; }
void decStrong() const { if (--mCount == 0) delete static_cast<T*>(this); } // 자식의 객체를 없애기 위해서는 자식 타입으로 캐스트 필요 함.
// 그를 위해서 CRTP를 쓸 수 있음. // this가 상수 함수라서 안됨.
//방1 const_cast로 상수성을 없앨 필요 함. 그리고 static_cast
//방2 static_cast<const T*>로 한번만 캐스트.
};
class Truck : public RefBase<Truck> {
~Truck() { cout << "~tr" << endl; }
};
int main() {
const Truck *p = new Truck;
p->incStrong();
p->decStrong();
}
#include <iostream>
using namespace std;
/*
트리비얼 : 생성자, 소멸자, 복사 생성자등이 아무일도 하지 않는 경우
트리비얼 생성자 : 생성자 호출없이 malloc만으로 충분하면 트리비얼 생성자라 할 수 있다.
트리비얼 소멸자,
트리비얼 복사 생성자 등.
생성자 trivial의 정의
1. 사용자가 만든 생성자가 없고. B() = default도 trivial 함. B() {}는 non trivial
2. 가상함수가 없고
3. 부모가 없거나 부모의 생성자가 trivial하고
4. 객체형 멤버가 없거나 객체형 멤버의 생성자가 trivial 할 때
*/
class A {};
class B : public A {
int data;
public:
virtual void foo() {
}
};
int main() {
// B의 생성자는 trivial한가 ?
// 아님. 왜냐하면 virtual이 있어서 virtual 테이블이 포함됨.
B* p = (B*)malloc(sizeof(B));
p->foo();
// 크래시 남. 생성자 부르지 않아 발생.
// 가상함수 테이블 초기화를 생성자가 해야 함.
new(p) B; //이미 존재하는 객체메모리에 생성자만 다시 호출 : placement new
}
#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
/*
trivial : big 5 + 소멸자 함수가 하는 일이 있는지 없는지 나타낸다. (생,소, 복, move, move 대입연산자) 메모리를 보는게 아니라 함수가 하는일이 있는지 검사.
standard layout : 메모리 layout이 C와 동일한 구조인가 ?
1. 모든 멤버가 동일 접근 지정자
2. 가상함수가 없어야 한다.
POD는 : is_trivial(함수의 개념) && is_standard_layout(메모리 배치) 이다.(결국의 C의 구조체와 동일하게 사용가능함. Plain Old Data. memset, memcpy 등을 사용해도 된다는 것.)
C++11에서 정의 된 개념 임.
*/
struct Point {
int x, y;
public:
void foo() {} // virtual 아닌 멤버 함수는 standard나 trivial에 영향 안줌.
Point() = default; // 역시 영향 안 줌.
// Point() {}
//virtual void foo() {}
};
int main() {
cout << is_standard_layout<Point>::value << endl;
cout << is_trivial<Point>::value << endl;
}
#include <iostream>
#include <type_traits>
using namespace std;
// 모든 배열을 복사하는 함수
template <typename T> void copy_type(T*dst, T*src, int sz) {
if (is_trivially_copyable<T>::value) {
cout << "copy ini does nothing (trivial)" << endl;
memcpy(dst, src, sizeof(T) *sz);
}
else {
cout << "non trivial" << endl;
while (sz--) {
new(dst) T(*src);
++dst, ++src;
}
}
}
int main() {
char s1[10] = "hello";
char s2[10];
//strcpy(s2, s1);
copy_type(s2, s1, 10);
}
#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
atomic<int> x = 0;
void foo() {
for (int i = 0; i < 1000000; i++) {
//x += 1;
x.fetch_add(1);
/*
__asm {
mov eax, x
add eax, 1
mov x, eax
}
*/
// lock : 하나의 cpu 가 사용하는 메모리를 다른 cpu가 사용하지 못하게 하는 prefix (접두어)
// lock free : OS의 lock 없이 동기화 코드 작성( cpu의 lock 사용.)
/*
__asm {
lock inc x
}
*/
}
}
int main() {
thread t1(&foo);
thread t2(&foo);
thread t3(&foo);
t1.join(); t2.join(); t3.join();
cout << x.load() << endl;
}
#define __ENABLE_ATOMIC_ALIGNMENT_FIX
#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
struct Point {
int x, y;
};
struct Point2 {
int x, y, z;
};
atomic<int> n;
atomic<Point> p;
atomic<Point2> p2;
int main() {
cout << n.is_lock_free() << endl; // CPU lock OK.
cout << p.is_lock_free() << endl; // ?? 크기가 64비트. CPU Lock으로 커버 가능.
cout << p2.is_lock_free() << endl; // 0. 지원 안됨.
Point p4;
p2.store(p4); // 멀티스레드에 안전하게 p=p3된다.
}
#include <iostream>
#include <thread>
#include <atomic>
using namespace std;
struct Point {
int x, y;
void goo(); // aggregate 맞음.
virtual void foo() { } // aggreage 아님
Point() = default; // aggregate
//
Point() { cout << "Point () " << endl; } // C++ class
//
Point(int a, int b) :x(a), y(b) { cout << "Point (int, int)" << endl; }
};
int main() {
Point p1;
Point p2(1, 2); // 기존
Point p3{ 1, 2 }; // C++11
Point p4 = { 1, 2 };//C++11 // aggregate : C구조체와 같이 초기화 가능한 것
}
#include <iostream>
using namespace std;
#if 0
class Point {
int x, y;
public:
Point(int a = 0, int b = 0) : x(a), y(b) {}
};
int main() {
Point p1, p2;
Point p3 = p1 + p2; // 방1 : p1.operaotor+(p2);
// 방2 : operator+(p1, p2);
// 둘다 만듬 1번 부름. 보통은 2번을 선호 함.
}
#endif
class Point {
int x, y;
public:
Point(int a = 0, int b = 0) : x(a), y(b) {}
Point operator+(const Point&p) {
cout << "mem" << endl;
return Point(x + p.x, y + p.y);
}
/*
friend Point operator+(const Point&p1, const Point &p2) {
cout << "friend" << endl;
return Point(p1.x + p2.x, p1.y + p2.y);
}
*/
};
int main() {
Point p1, p2;
Point p3 = p1 + p2; // 방1 : p1.operator+(p2);
// 방2 : operator+(p1, p2);
// 둘다 만듬 1번 부름. 보통은 2번을 선호 함.
int n = 5;
Point p4 = p1 + n; // Point + int : Point + int 필요. 없더라도 friend 함수 경우 암시적 형변환 된다.
Point p5 = n + p1; // int + Point : int n에 대하여, n.operator+() 정의가 없다. member 함수 구현 경우 에러 발생. 때문에 friend 함수가 이경우 좋다.
// 이항은 friend로. 단항은 member로 만든다.
}
#include <iostream>
using namespace std;
#if 0
class Point {
int x, y;
public:
Point(int a = 0, int b = 0) : x(a), y(b) {}
};
int main() {
Point p1, p2;
Point p3 = p1 + p2; // 방1 : p1.operaotor+(p2);
// 방2 : operator+(p1, p2);
// 둘다 만듬 1번 부름. 보통은 2번을 선호 함.
}
#endif
namespace Util {
class Point {
int x, y;
public:
Point(int a = 0, int b = 0) : x(a), y(b) {}
friend Point operator+(const Point&p1, const Point &p2);
};
Point operator+(const Point&p1, const Point &p2) {
cout << "friend" << endl;
return Point(p1.x + p2.x, p1.y + p2.y);
}
}
int main() {
Util::Point p1, p2;
Util::Point p3;
p3 = p1 + p2; // ?? +는 Util namespace에 있는데 ?? 어떻게 참조 되나 ?.
p3 = Util::operator+(p1, p2); // global에서 +를 찾고, 없으면 인자 p1, p2의 namespace에서 찾는다. 인자기반 검색. ADL. Arguement Depedent Lookup.
// 굳이 operator가 아니더라도 일반 함수도 마찬가지. 인자가 여러가지면 반드시 적어야 함.
p3 = p1 + p2; // 이것은 ADL 때문에 가능함.
}
#include <iostream>
#include <thread>
#include <atomic>
/*
동적 할당 된 메모리 해제
1. void * 타입으로 free()는 가능. 하지만, delete는 절대 안됨. (void * 타입에 대해서는 소멸자를 부를 수가 없음)
*/
using namespace std;
class Test; // 클래스 전방 선언 - 완전한 선언 없어도 포인터는 사용 가능. 단, 실행하면, 소멸자가 안불림 !!!!!!
Test* pt; // imcomplete object(불완전 객체) delete시 소멸자 호출 안됨 !!!!. 클래스의 전방 선언만 앞에 있는 경우 발생하는 전형적인 문제.
// 그 방어 책으로, 메모리 해제 하는 함수앞에 sizeof(T)를 해줄 수 있다. sizeof는 당연히 complete 타입만 가능기 때문에 imcomplete object에 대해서는 에러 발생.
// checked delete 기법 : boost 진영에서 처음 소개. 요즘에는 static_assert를 이용해서 점검 함.
void foo(Test*p) {
//sizeof(Test); // 기존
static_assert(sizeof(Test) > 1, "error, imcomplete type"); // 최신 방안
delete p;
}
struct Test {
int data;
public:
Test() { cout << "Test()" << endl; }
~Test() { cout << "~Test()" << endl; }
};
void goo(void *p) { // 절대 안됨 ! 소멸자 안불림.
delete p;
}
int main() {
Test *t = new Test;
foo(t);
}
#include <iostream>
#include <memory>
using namespace std;
int main() {
unique_ptr<int> p1(new int);
unique_ptr<int> p2((int*)malloc(100));
}
#include <iostream>
using namespace std;
class Point {
int x = 0, y = 0;
public:
Point() { cout << "Point () " << endl; }
~Point() { cout << "~Point () " << endl; }
Point(const Point&) { cout << " copy " << endl; }
};
// 책은 RVO를 지원하기 위해서 모든 멤버는 생성자에서 초기화 하자는 이야기 임.
// (다만, 현재는 대부분의 컴파일러가 NRVO를 지원하기 때문에 큰 의미가 없음.)
// 2단 생성자 방식과 충돌 됨.
/*
Point foo() {
Point p;
return p; // "값 타입"으로 리턴하면 임시객체가 리턴됨. return Point(p);의 의미. 성능 저하 있음.
}
*/
Point foo() {
return Point(); // 만들고 리턴하지 말고, 만들면서 리턴하자. RVO return value optimization // 성능 개선 됨.
}
// NRVO : Named RVO --> 이름 있는 객체도 컴파일러가 최적화 하면서 임시 객체가 제거 되는 현상 (2000년대 중반 도입)
int main() {
Point p1;
p1 = foo();
}
#include <iostream>
using namespace std;
int cnt = 0;
class Point {
int x = 0, y = 0;
public:
Point() { cout << "Point () " << endl; }
~Point() { cout << "~Point () " << endl; }
Point(const Point&) { cnt++; cout << " copy " << endl; }
};
Point foo() {
Point p;
return p;
}
int main() {
Point p1;
p1 = foo();
cout << cnt << endl;
}
#include <iostream>
using namespace std;
int cnt = 0;
class Point {
int x = 0, y = 0;
public:
Point() { cout << "Point () " << endl; }
~Point() { cout << "~Point () " << endl; }
//Point(const Point&) { cnt++; cout << " copy " << endl; }
Point(const Point&) = delete;// { cnt++; cout << " copy " << endl; }
};
Point makePoint() {
//
Point p;
//
return p;
return Point();
}
int main() {
Point p = Point(); // 1. 임시객체 생성
// 2. 복사 생성자로 임시객체를 p에 복사
// 3. 하지만최적화를 통해서 복사 생성자 호출 제거.
// 복사 생성자가 없으면 error
// 단 C++17에서는 OK. mandatory RVO : RVO 시 복사 생성자가 없어도 컴파일 됨. g++ -std=c++1z
//p1 = makePoint();
}
#include <iostream>
using namespace std;
// 초기화 순서 !!! 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
// 소멸자는 생성자가 완벽하게 실행하지 못하면 안불림 !!
// 2단생성자 : 2번의 함수 호출로 개체를 초기화 하는 개념
struct Data {
int * p;
public:
Data() {
p = new int; // 자원 할당
// 그 다음에, DB 접속 시도하다가 실패...
// 생성자에 실패했다는 사실을 외부로 알릴 방법은 exception 또는 flag
// 보통은 exception 사용
throw 1;
}
~Data() { delete p; cout << "~Data" << endl; } // 자원 해제
};
int main() {
try {
Data d;
}
catch (...) {
// 이경우는 소멸자가 안불림. 소멸자는 생성자가 완벽하게 실행하지 못하면 안불림 !!
// 자원 할당 된 리소스 delete할 시점이 없음. memory leak 발생.
// throw 전 release 필요.
}
}
#include <iostream>
using namespace std;
// 초기화 순서 !!! 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
// 소멸자는 생성자가 완벽하게 실행하지 못하면 안불림 !!
// 2단생성자 : 2번의 함수 호출로 개체를 초기화 하는 개념
// 해결책 2가지가 있음.
// 방안 1: RAII (Resource Acqusition Is Initialize)
// 스마트 포인터 사용
#include <memory>
struct Data {
unique_ptr<int> p;
public:
Data() : p(new int) {
//p = new int; // unique_ptr에서는 생성과 함께 초기화 필요 함. 초기화 리스트로 초기화해야 함.
throw 1;
}
~Data() { cout << "~Data" << endl; } // 자원 해제
};
int main() {
try {
Data d;
}
catch (...) {
}
}
#include <iostream>
using namespace std;
// 초기화 순서 !!! 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
// 소멸자는 생성자가 완벽하게 실행하지 못하면 안불림 !!
// 2단생성자 : 2번의 함수 호출로 개체를 초기화 하는 개념
// 해결책 2가지가 있음.
// 방안 2: 2단생성자
//
struct Data {
int *p;
public:
Data() : p(0) {} // 이 생성자에서는, 생성자 동작 중 예외 가능성이 있는 어떠한작업도 하지 말자.
void Construct() {
p = new int;
throw 1;
}
~Data() { delete p; cout << "~Data" << endl; } // 자원 해제
};
int main() {
try {
Data d; // 생성자는 예외 가능성이 없기 때문에 정상 동작
d.Construct(); // 이 단계에서 에러가 나더라도, 기 생성자가 에러가 없었기 때문에 ~Data()가 정상 불림.
}
catch (...) {
}
}
#include <iostream>
using namespace std;
void foo(int n) { // 1
}
void foo(void *n) { // 2
}
void goo(char * n) {
}
int main() {
// 0은 정수 임.
foo(0); // 1
foo((void*)0); // 2
// #define NULL (void*)0 //C의 NULL
// #define NULL 0 //C++의 NULL
goo(NULL); // void * to char * : C OK. C++ NG.
foo(NULL); // C++ 1로 감.
}
#include <iostream>
using namespace std;
void foo(int n) { // 1
}
void foo(void *n) { // 2
}
void goo(char * n) {
}
// 포인터 0을 만들어 봅시다.
struct xnullptr_t {
// void*로의 암시적 형변환 제공
//operator void*() { return 0; }
template<typename T>
operator T*() { return 0; }
};
xnullptr_t xnullptr;
int main() {
foo(0);//1
foo(xnullptr); //2
goo(xnullptr); // OK
}
#include <iostream>
using namespace std;
// 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
struct Buf {
Buf(int sz) { cout << " buf init" << endl; } // 버퍼를 하나 만듬.
};
class Stream {
public:
Stream(Buf* f) { cout << "stream init" << endl; } // 버퍼에 데이터를 씀.
};
// 해결책. buffer를 담은 부모를 만드는 것.
class BufferManager {
protected:
Buf buf;
public:
BufferManager(int sz) : buf(sz) {
}
};
class MyStream : public BufferManager, public Stream {
public:
MyStream(int sz) : BufferManager(sz), Stream(&buf) {
}
};
int main() {
//
Buf buf(1024);
//
Stream s(&buf);
MyStream ms(1024);
}
#include <iostream>
using namespace std;
// 부모의 멤버와 내 멤버의 초기화 순서
// 1. 코드 순서와 관계 없이 부모의 멤버가 초기화 되고
// 2. 그 다음에 내 멤버의 초기화가 일어 남.
// 3. 그 다음이 자기 자신의 생성자
// 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
struct Buf {
Buf(int sz) { cout << " buf init" << endl; } // 버퍼를 하나 만듬.
};
class Stream {
public:
Stream(Buf* f) { cout << "stream init" << endl; } // 버퍼에 데이터를 씀.
};
class MyStream : public Stream {
Buf buf;
public:
MyStream(int sz) : buf(sz), Stream(&buf) { // buf 보다 Stream 이 먼저 불린다 !!! 나열 순서랑 상관 없음 !!!!!!
}
};
int main() {
//
Buf buf(1024);
//
Stream s(&buf);
MyStream ms(1024);
}
#include <iostream>
using namespace std;
// 메모리 복사 없이 구조체(POD) 뒤집기
/*
1. 원래 구조체의 멤버의 순서를 반대로 가진 구조체를 만들자
2.
*/
// pair의 반대 구조체를 정의하고 캐스팅한다는 것이 개념.
template<typename P> struct Reverse {
typedef typename P::first_type second_type;
typedef typename P::second_type first_type;
second_type second;
first_type first;
};
int main() {
pair <int, double> p(1, 3.4);
cout << p.first << endl;
cout << p.second << endl;
cout << p.first << endl; // 3.4
cout << p.second << endl; // 1
}
/*
부모에 friend 선언 되어 있음. operator
상속 받은 클래스의 경우는 부모의 friend 선언 유효 함.
그런데, 자식 클래스에서 friend 함수 operator를 재 선언 가능 함.
그런데, main에서 자식을 부모로 down casting했을 때
그 때는 어떤 << operator가 불리는가 ?
기본은 부모의 <<가 불림.
멤버가 아닌, 일반 함수에 대해서도 virtual을 하고 싶은데, 불가능 함.
일반 함수를 virtual로 만들 방법이 없을 까 ?
->
우선 부모에 virtual 멤버 함수를 만들어 준다. 그리고 friend 함수에서는 그 버추얼 멤버 함수를 불러주도록 하면 된다.
자식도 마찬가지로 virtual 함수만 재정의 해주면 된다. friend 함수는 자식에서는 선언 불필요 함.
즉, 부모 자식 각각 friend 함수 선언하지 않고, friend 함수는 하나 이지만 거기서 부모 자식의 virtual을 불러주게 함으로써
마치 friend 함수가 버추얼인 것처럼 동작 하게 함.
*/
#include <iostream>
using namespace std;
// 초기화 순서 !!!
// 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
class Base {
public:
Base() { init(); } // 생성자에서는 가상함수가 동작하지 않는다 !!!!
// 부모 생성자가 초기화 되는 시점에서는 Derived 의 멤버가 아직 초기화 되어 있지 않다.
virtual void init() { cout << "Base init" << endl; }
};
class Derived : public Base {
int data;
public:
Derived() : data(30) {}
virtual void init() { cout << "Derived init " << data << endl; }
};
int main() {
//Base b;
Derived d;
}
#include <iostream>
using namespace std;
// 초기화 순서 !!!
// 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
// 해결책. 1. 2단 생성자 ( two phase constructor ! 타이젠은 2단 생성자로 라이브러리 구성)
// 생성자에서는 아무것도 안함. 대신에 Construct()에서 virtual 불러 준다.
class Base {
public:
Base() { } // 생성자에서는 가상함수가 동작하지 않는다 !!!!
// 부모 생성자가 초기화 되는 시점에서는 Derived 의 멤버가 아직 초기화 되어 있지 않다.
void Construct() { init(); }
virtual void init() { cout << "Base init" << endl; }
};
class Derived : public Base {
int data;
public:
Derived() : data(30) {}
virtual void init() { cout << "Derived init " << data << endl; }
};
int main() {
//Base b;
// Two phase solution. 삼성 타이젠 방식.
Derived d; // 1단계
d.Construct(); // 2단계
}
#include <iostream>
using namespace std;
// 초기화 순서 !!!!!!!
// 1. 기반 클래스 생성자 2. 멤버 생성자 3. 자신의 생성자
// 해결책. 2.
template<typename T>
class Base {
public:
Base() { // this->init(); this의 타입: Base*
(static_cast<T*>(this))->init(); // 하지만 위험하다 !!!! Derived의 data가 아직 초기화 안되어 있다 !!!! 차라리 2단 생성자가 낫다.
}
void init() { cout << "Base init" << endl; }
};
class Derived : public Base<Derived> {
int data;
public:
Derived() : data(30) {}
virtual void init() { cout << "Derived init " << data << endl; }
};
int main() {
Derived d; // 하지만 위험하다.
}
#include <iostream>
using namespace std;
/*
Animal
Dog : Animal
Cat : Animal 일 때
static_cast 무조건 캐스팅 // 컴파일 시간 캐스팅. 성능 저하 없음.
dynamic_cast p가 Dog인지 조사 후 캐스팅 // 실행시간 캐스팅. 성능 저하 있음. 가상 함수가 한개 이상 있어야 함.
Dog가 아니면 0
*/
