메모내용
Nav

CPP Syntax

함수명_s

secure function

보완 함수
오버플로우를 막기 위해 버퍼의 크기를 지정하도록 하는 함수

const 함수

멤버 변수를 바꾸지 않도록 하는 함수

                        
                            class ???{
                                
                                FString Name;
                                
                                /*
                                함수 서명 뒤에 const 를 붙임으로서 함수내에서
                                멤버변수를 바꾸지 않을것을 약속하였다.
                                또 이어서 반환형 또한 const 인데,
                                만약 FString& 으로 멤버변수를 반환한다면,
                                받은 반환값으로 멤버변수를 수정해버릴 수 있기 때문에,
                                멤버 변수를 참조로 반환하는경우
                                const 를 써 주어야 말이 된다.*/
                                const FString& GetName() const { return Name;}
                            }
                        
                    

explicit 키워드

Explicit : 명백한 뚜렷한 Inplicit : 암묵적으로 함수에 붙여, 매개변수가 자동으로, 자신이 원하지 않은 형변환이 일어나지 않도록 제한하는 키워드 생성자와 형변환 연산자에 주로 붙인다.

참고 - dydtjr1128's Blog :: explicit
                        
                            #include 
                                class A{
                                public:
                                   int num;
                                   A(int n) : num(n){};
                                };
                                void printA(A a){
                                   std::cout << a.num << std::endl;
                                }
                                int main(){
                                   int n = 26;
                                   printA(n);
                                }
                                
                        
                    

위의 코드에서는 printA(A a) 함수의 인자로 들어오는 26이라는 숫자가 컴파일러에 의해 A 형태로 바뀌게 된다. 이때 A(int n)이라는 생성자를 통해서 바뀌게 되는 것이다. explicit call stack위의 사진은 A의 생성자에서 중단점을 걸고 Call stack을 본 내용이다. 위의 내용처럼 사용자가 형변환을 하지 않더라도 자동적으로 형변환을 위해 생성자가 불리는 것을 알 수 있다.

                        
                            #include <iostream>
                                class A{
                                public:
                                   int num;
                                   explicit A(int n) : num(n){};
                                };
                                void printA(A a){
                                   std::cout << a.num << std::endl;
                                }
                                int main(){
                                   int n = 26;
                                   printA(n); //Error!
                                }
                                
                        
                    

하지만 위처럼 생성자에 expilict 키워드를 사용한다면 컴파일러가 알아서 형변환 하는것을 막을 수 있다. 이처럼 explicit 키워드 없이 사용한다면 사용자가 원치 않은 형변환이 일어나는 등 예기치 않은 버그가 발생할 수 있기 때문에 사용해 주는 것이 좋다. explicit 키워드를 사용한다면 사용자가 상황에 맞게 직접 형 변환을 해주어야 한다.

                        
                            int main(){
                                int n = 26;
                                printA(A(n)); //OK
                             }    
                        
                    

형변환 연산자 오버로딩

Type conversion operator

형변환 연산자는 해당 클래스를 특정 타입으로 변환할 때 호출되는 함수이다. 이때는 함수 선언시 반환형을 따로 명시하지 않는다.

                        
#include <iostream>

class MyClass{
private:
    uint32_t value;
public:
    MyClass(uint32_t val) : value(val) {}

    // 형 변환 연산자 오버로딩
    operator uint32_t() const{
        return value;
    }
}


int main(){
    MyClass obj(42);

    // 암시적 변환 (Implicit Conversion)
    uint32_t num = obj;
    std::cout << "nnm: " << num << std::endl; // 출력 : num : 42

    // 명시적 변환 (Explicit Conversion)
    uint32_t num2 = static_cast<uint32_t>(obj);
    std::cout << "num2: " << num2 << std::endl; // 출력 : num2 : 42

    return 0;
}
                        
                    

volatile

C++ 에서와 C# , JAVA 에서의 기능이 다르다. C++ 에서는 단순히 최적화를 하지 말아달라고 요청하는 것이다. 컴파일러 입장에서 미리 평가 하여, 최종값만 입력하는 경우가 있는데, volatile 이 붙어 있는 변수라면, 최적화하지 않고, 모든 연산을 그대로 수행합니다.

가변길이 매개변수

C++ 템플릿을 이용하면 임의의 갯수의 인자를 받는 함수를 구현할 수 있다.

참조 - koreanfoodie's study :: 가변길이 템플릿

클래스 전방선언

자주 사용하는 객체는 헤더파일의 참조 없이 멤버변수로 선언하는 방법, 포인터로 선언해야한다. 헤더파일에서 같은 모듈에 있는 다른 헤더파일을 참조하지 않아도 되므로 상호참조를 방지하는 한편, 코드구조를 관리하기도 좀더 용이해 진다. 단. 전방선언한 변수의 멤버는 호출할수 없다. 전방선언한 변수의 멤버변수나 함수를 쓰고싶으면, 헤더파일을 참조해서 쓰도록 하자.

                        
        class ClassName* VariableName;