몰입이 터지다

//C++ 문법 메모

#pragma once                     // 해당 헤더 파일이 한 번만 포함되도록 규정한다. 지원하지 않는 컴파일러도 있음.
#ifndef, #define, #endif   // Header Guard. 표준으로 모든 컴파일러가 지원.

#define PLATFORM_MAC 0

namespace LyraHero
{
static const float LookYawRate = 300.0f;
static const float LookPitchRate = 165.0f;
};
LyraHero::LookYawRate

using A_COM::function;
using namespace A_COM;
    ->namespace를 계속 표기하기 귀찮을 때 using 사용

class Door
{
void Open();
};
void Door::Open(){......};     // Door클래스의 Open 함수를 외부에서 정의하기. cpp 파일이 주로 이런 형태다. 

Door d[5];    //객체배열. 배열에 객체가 자동 생성됨.
Door* d[5];   //객체포인터배열. new 객체 생성을 해야함.

this->aaa     //클래스 변수를 표시할 때.

friend 선언을 한 함수를 통해서 private 멤버변수 접근이 가능하다.

protected:    //상속관계에서는 public, 외부에서 보면 private

class Student : public Person          //public상속.         private:접근불가, protected : protected, public : public
class Student : protected Person   //protected상속.   private:접근불가, protected : protected, public : protected
class Student : private Person        //public상속.         private:접근불가, protected : private,      public : private

Person* p = new Student;    //객체 포인터. 

Student p;
Person& ref = p;       // 객체 레퍼런스

virtual void fct(){}    // 오버라이딩 되는 함수를 virtual 로 선언. 함수가 dynamic binding 된다는 의미. 오버라이딩 된 함수만 실행됨.
                                // virtual 함수를 오버라이딩한 함수도 virtual이 되므로 상속에 의해서 가려지게 됨.
virtual int GetPay()=0  // =0을 붙이면 순수 virtual 함수
BBB b;  b.fact();                       // static binding
AAA* a = new BBB;  a->fct();   // dynamic binding
a->fct()                                    // BBB에 정의된 fct()가 호출된다.
a->AAA::fct()                           // AAA에 정의된 fct()가 호출된다. (객체화를 생각해서 사용하지 말자)

class CCC : public AAA, public BBB{}    // 다중 상속
AAA::String();   BBB::String();            // 다중 상속시 같은 이름의 함수는 범위를 지정해야 한다.
class BBB : virtual public AAA{}          // virtual 상속.  DDD클래스가 BBB, CCC를 다중 상속 할 때, 베이스인 AAA를 한번만 상속하게 함.

--------------------------------------------
template <typename T>
T Add(T a, T b)
{
return a+b;
}
Add(10,20);
--------------------------------------------
template <typename T1, typename T2>  //함수 템플릿. 둘 이상의 타입에 대해서 템플릿화 하기.
void ShowData(T1 a, T2 b)
{
cout<<a<<endl;
cout<<b<<endl;
}
--------------------------------------------
template <typename T>
int SizeOf(T a)
{
return sizeof(a);
}
template<>                 //함수 템플릿 특수화. 
int SizeOf(char* a)   //char* 인자의 경우에 이 함수를 호출.
{
return strlen(a);
}
--------------------------------------------
template <typename T>    //클래스 템플릿
class Data
{
T data;
public:
Data(T d){
data = d;
}
}
Data<int> d1(0);
Data<char> d2('a');
--------------------------------------------
정의를 분리해서 선언하는 형태는 아래와 같다. 템플릿 함수는 하나의 파일 안에 선언과 정의가 있어야 한다.
template <typename T>
Data<T>::Data(T d){
data=d;
}
template <typename T>
void Data<T>::SetData(T d){
data=d;
}
template <typename T>
T Data<T>::GetData(){
return data;
}

---------------------------------------------------------------------------------------------------------------------
const int n=10;
    ->정수형 상수 n을 선언하고, 그 값을 10으로 초기화한다. 이 선언 이후에는 n의 값을 변경하려고 하면 컴파일 오류가 발생한다.
const int* n;
    ->int형 상수를 가리키는 포인터를 선언한다. n을 통해 값을 수정할 수는 없지만, n이 가리키는 주소는 변경할 수 있습니다.
    이는 포인터를 통해 값을 보호하고, 실수로 값을 변경하는 것을 방지하는 데 유용하다.
const int* n;  // int형 상수를 가리키는 포인터 선언
    int value = 10;
    n = &value;    // n은 value의 주소를 가리킴
    // *n = 20;  // 오류: n을 통해 값을 수정할 수 없음 (const로 인해 읽기 전용)
    value = 20;  // 가능: value 자체는 상수가 아니므로 수정 가능
int* const n;
    ->포인터 자체가 상수입니다. 즉, 포인터가 가리키는 주소는 변경할 수 없지만, 그 주소에 저장된 값은 변경할 수 있다.
int n1=10;
int n2=20;
int* const pN = &n1;
*pN=20
// pN = &n2   // 컴파일오류.포인터 자체가 상수
const int* const n;
    ->포인터가 가리키는 주소와 그 주소에 저장된 값 모두 상수입니다. 즉, 둘 다 변경할 수 없다.

Class Student
{
const int id;
Student(int _id) : id(_id) {}    // : 뒤의 표기가 멤버 이니셜라이져. const 값에 null 로 초기화되어 수정이 불가하기에 사용.
}

void ShowData() const {}    //const 멤버함수. 이 함수를 통해서 멤버 변수 값의 변경을 허용하지 않는다는 뜻. (출력전용)
//const멤버함수는 const 되지 않는 함수 호출을 허용하지 않고, 멤버 변수의 포인터를 리턴하는 것도 허용하지 않는다.
int cnt;
const int* GetPtr() const     //포인터가 가리키는 데이터를 const화. 멤버 변수 포인터 리턴 처리.
{
return &cnt;
}

Const Door d(10);    // const 클래스. 멤버변수 조작은 불가능하고  const화된 함수만 호출 가능해진다.


---------------------------------------------------------------------------------------------------------------------
int data=10;
int *ptr;                //ptr은 주소값이고 *ptr은 주소가 가리키는 데이터 값이다.
ptr = &data;          //포인터 선언을 따로 했을 때 주소 값 지정하기.
int *ptr = &data;   //포인터 선언과 동시에 초기화
*ptr++                   //ptr 변수의 주소 위치를 하나 증가 (포인터 변수의 자료형 만큼 증가)
(*ptr)++                //*ptr 주소가 가리키는 데이터 값을 하나 증가

int *pVal = &val;      //주소 값을 얻기 위해 &연산자 사용
int &rVal = val;        //레퍼런스 선언을 위해 &연산자 사용. 
int &rVal2 = rVal    // 레퍼런스 선언 후에는 rVal 은 val 과 똑같이 사용한다.
void ShowData(const Person &p){} // 레퍼런스를 이용해서 Call-By-Reference 처리에 사용한다.

int& increment(int &val)
{
val++;
return val;
}
int n=10;
int &ref=increment(n);
cout<<n<<endl;
cout<<ref<<endl;         //n, ref 값 모두 11이 출력된다.
---------------------------------------------------------------------------------------------------------------------

static int count;       // public으로 선언되면 객체 생성 이전에도 접근가능하다. 객체 멤버로 존재하는 것이 아니고, 클래스 내에서 접근할 수 있는 권한이 부여된 것이다.
int AAA::count=1;    // static 멤버 초기화

explicit Door(int n){}  //명시적인 호출만 허용한다.  Door d = 10 과 같이 묵시적 변환은 컴파일 에러가 발생한다.

mutable int val;         //const화된 함수에서도 변수를 수정할 수 있다.
int val2;
void SetData(int a, int b) const
{
val=a;    //mutable 이므로 수정 가능.
val2=b;  //컴파일 에러
}

---------------------------------------------------------------------------------------------------------------------
extern 키워드 :다른 파일에 정의된 변수나 함수를 참조할 때 사용. 전역 변수를 여러 파일에서 공유하거나, C++와 C 코드를 혼용할 때 유용

// File1.cpp
#include <iostream>
int globalVar = 42; // 전역 변수 정의

// File2.cpp
#include <iostream>
extern int globalVar; // 외부 변수 선언

int main() {
    std::cout << "GlobalVar: " << globalVar << std::endl; // File1.cpp의 globalVar 사용
    return 0;
}
---------------------------------------------------------------------------------------------------------------------
override 키워드 : 부모 클래스의 virtual 함수를 재정의함을 명시적으로 표기. 
void MyFunction() const override;
---------------------------------------------------------------------------------------------------------------------