C++/문법/클래스

1. 개요[편집]

class /*클래스 이름*/
{
    ...
};

2. 캡슐화[편집]

class Squirrel
{
public:
    std::string myName;
    size_t myAge;
    float myWeight;

    std::vector<Acorn*> myAcorns;
};

2.1. 정보 은닉[편집]

struct Nest
{
    // public
    std::vector<Acorn*> everyAcorns;
};

class Squirrel
{
public:
    std::string myName;
    size_t myAge;
    float myWeight;

private:
    Nest* myNest;
};

private

protected

public

private

public

private

public

protected

2.2. 데이터 멤버[편집]

class Squirrel
{
public:
    std::string myName;
    size_t myAge;
    float myWeight;

private:
    Nest* myNest;
};

int main()
{
    Squirrel squirrel1;
    squirrel1.myName = "The first squirrel";
    squirrel1.myAge = 1;
    squirrel1.myWeight = 2.0f;
    squirrel1.myNest = new Nest; // 접근 권한 오류!

    Squirrel squirrel2{}; // 중괄호를 사용한 기본 초기화
    size_t& squirrel2_age = squirrel2.myAge; // 이제 squirrel2_age로 접근 가능함

    Squirrel squirrel3{ "The third squirrel", 3, 1.6f }; // 결집 구조체(Aggregate) 방식의 초기화
}

.

->

enum class Gender { NonBinary = 0, Male, Female, Lesbian, Gay, Binary, TransgenderMF, TransgenderFM, };

class Squirrel
{
public:
    std::string myName;
    size_t myAge;
    float myWeight;
    Gender myGender;

    const bool canFly; // 상수 변수는 반드시 초기화 해야 한다
    Nest& myNest; // 'myNest' 참조 변수는 반드시 초기화해야 한다
};

int main()
{
    Squirrel squirrel1{}; // 오류! 상수와 참조 멤버를 초기화하지 않았습니다.

    Nest nest_in_tree{}; // 도토리 0개
    Squirrel squirrel2{ "The second squirrel", 5, 3.0f, Gender::Male, false, nest_in_tree };

    Acorn* nut_on_floor = new Acorn{};
    squirrel2.myNest.push_back(nut_on_floor); // .로 벡터 필드 'myNest' 접근 (nest_in_tree가 참조됨)

    size_t acorn_count = nest_in_tree.size(); // 도토리 1개
}

const

volatile

&

&&

&

&&

&&

2.3. 멤버 함수[편집]

class Squirrel
{
public:
    void Wake() {}
    void Sleep() {}
    void Run() {}
    void Eat(Acorn* acorn) {}
    void Save(Acorn* acorn) {}
    
    std::string GetName() const { return myName; }
    size_t GetAge() const { return myAge; }
    float GetWeight() const { return myName; }

    std::string myName;
    size_t myAge;
    float myWeight;

private:
    std::vector<Acorn*> myAcorns;
};

2.4. this[편집]

import <print>;

class MyClass {
public:
    void GetMember()
    {
        int variable = 7331;
        this->variable = 1337;
        std::println(variable, this->variable); // 7331, 1337
    }

    void GetMember2()
    {
        variable = 1337; // 필드
        std::println(this->variable); // 1337
    }

private:
    int variable;
};

this

2.5. 정적 멤버[편집]

class Squid
{
public:
    static Squid* Create()
    {
        return new Squid;
    }

    static constexpr bool isMammal = false;
    static const bool canFly; 
};
const bool Squid::canFly = false; // C 방식의 정적 필드 정의

class Squirrel
{
public:
    static Squirrel* Create()
    {
        return new Squirrel;
    }

    static constexpr bool isMammal = true;
    static inline const bool canFly = false; // C++11의 inline을 사용한 정적 필드 정의
};

class FlyingSquirrel
{
public:
    static FlyingSquirrel* Create()
    {
        return new FlyingSquirrel;
    }

    static constexpr bool isMammal = true;
    constinit static bool canFly = true; // C++17의 constinit을 사용한 컴파일 시간 정적 필드 정의
};

2.6. 멤버 자료형[편집]

2.6.1. 멤버 클래스[편집]

import <string>;
import <algorithm>;

struct Person;

class Airplane
{
public:
    [[nodiscard]]
    constexpr bool IsOk() const noexcept
    {
        return airplaneCore.IsOk();
    }

protected:
    struct Machine // Airplane::Machine
    {
        [[nodiscard]]
        static constexpr bool CheckOk(const Machine& machine) noexcept // Airplane::Machine::CheckOk
        {
            return isOk;
        }

        bool isOk = false;
    };

    struct Core // Airplane::Core
    {
        struct Body // Airplane::Core::Body
        {
            struct Client // Airplane::Core::Body::Client
            {
                [[nodiscard]]
                constexpr bool IsOk() const noexcept
                {
                    return std::all_of(std::begin(myChairs), std::end(myChairs), Machine::CheckOk)
                        && std::all_of(std::begin(myAirpockets), std::end(myAirpockets), Machine::CheckOk);
                }

                Machine myChairs[250];
                Person myMembers[250];
                Machine myAirpockets[2];
            }

            [[nodiscard]]
            constexpr bool IsOk() const noexcept
            {
                return std::all_of(std::begin(myWings), std::end(myWings), Machine::CheckOk)
                    && std::all_of(std::begin(myTailWings), std::end(myTailWings), Machine::CheckOk)
                    && std::all_of(std::begin(myAntennas), std::end(myAntennas), Machine::CheckOk)
                    && myClients.IsOk();
            }

            Machine myWings[2];
            Machine myTailWings[3];
            Machine myAntennas[6];
            Client myClients;
        };

        [[nodiscard]]
        constexpr bool IsOk() const noexcept
        {
            return std::all_of(std::begin(myEngines), std::end(myEngines), Machine::CheckOk)
                && myDisplay.IsOk() && myFuelTank.IsOk()
                && myBody.IsOk();
        }

        Machine myDisplay;
        Machine myFuelTank;
        Machine myEngines[4];
        Body myBody;
    };

    Core airplaneCore;

private:
    std::string myName;
    Person myEmployee[20];
    Person myPilots[2];
}

2.6.2. friend[편집]

2.6.3. 자료형 별칭[편집]

import <memory>;

template<typename T>
class Trait
{
public:
    using type = T;
    using value_type = T;
    using const_type = const T;
    using reference = T&;
    using const_reference = const T&;
    using rvalue_reference = T&&;
    using const_rvalue_reference = const T&&;
    using pointer = T*;
    using const_pointer = const T*;
    using difference_type = std::ptrdiff_t;
};

template<typename _Ty, typename _Trait = Trait<_Ty>>
class MyVector
{
public:
    using value_type = _Trait<_Ty>::value_type;
    using const_type = _Trait<_Ty>::const_type;
    using reference = _Trait<_Ty>::reference;
    using const_reference = _Trait<_Ty>::const_reference;
    using rvalue_reference = _Trait<_Ty>::rvalue_reference;
    using const_rvalue_reference = _Trait<_Ty>::const_rvalue_reference;
    using pointer = _Trait<_Ty>::pointer;
    using const_pointer = _Trait<_Ty>::const_pointer;
    using difference_type = _Trait<_Ty>::difference_type;

    constexpr void Push(const_reference element);
    constexpr void Push(rvalue_reference element);

private:
    value_type* myBuffer;
};

3. 상속[편집]

import <iostream>;
import <string>;

class MyBase {
public:
    void print()
    {
        std::cout << text << 64 << '\n'; // My number is 64
    }

protected:
    std::string text = "My number is ";
};

class MyDerived : public MyBase {
public:
    void print()
    {
        std::cout << text << a << '\n'; // My number is 128
    }

    void legacy_of_void()
    {
        MyBase::print(); // 정적 메서드를 호출하는 것이 아니라, 기반 클래스의 print를 호출한다
    }

private:
    int a = 128;
};

class [파생 클래스 이름] : [접근성 지시자] [기반 클래스 이름]

private

protected

public

public

protected

protected

기반 클래스 이름::속성

MyDerived

MyBase

public

MyBase

std::string

text

print()

MyDerived

MyBase

text

protected

public

MyDerived

a

legacy_print()

3.1. 다중 상속[편집]

class BruceWayne : public RichMan, private Batman
{
    ...
};

BruceWayne

RichMan

public

Batman

private

4. 다형성[편집]

4.1. 가상 멤버 함수[편집]