👀 C++

위키독스를 주로 참조하여 공부했다.
이전 글 📚 혼자하는 C++ 공부 -1- 보러가기

Structure

#include<iostream>

using std::cout;
using std::cin;
using std::endl;
    
struct account{
    enum{
        NAME_LEN = 20,
        PW_LEN = 15,
    };
    char accountName[NAME_LEN];
    char accountPassword[PW_LEN];
    int accountNumber;
    int moneyInAccount;
    
    void deposit(int depositMoney);
    
    void changeName(){
        cin >> accountName;
    }
    
    inline void changePassword(){
        cin >> accountPassword;
    }
};

void showAllInformations(const account& thisAccount){
    cout << thisAccount.accountName << endl;
    cout << thisAccount.accountPassword << endl;
    cout << thisAccount.accountNumber << endl;
    cout << thisAccount.moneyInAccount << endl;
}

void account::deposit(int money){
    moneyInAccount += money;
}

int main(void){
    account seunghun { "seunghun", "1234", 123456, 2100000000 };
    showAllInformations(seunghun);
    seunghun.changeName();
    showAllInformations(seunghun);
    seunghun.changePassword();
    showAllInformations(seunghun);
    seunghun.deposit(1);
    showAllInformations(seunghun);
    return 0;
}

seunghun
1234
123456
2100000000
jaehyeon
jaehyeon
1234
123456
2100000000
987654321
jaehyeon
987654321
123456
2100000000
jaehyeon
987654321
123456
2100000001

구조체를 선언하여 사용했다. jaehyeon을 입력해 이름이 jaehyeon으로 바뀌었고, 987654321을 입력해 비밀번호를 바꾸었다.

Class

#include<iostream>
#include<string.h>

using std::cout;
using std::cin;
using std::endl;
    
class account{
private :
    enum{
        NAME_LEN = 20,
        PW_LEN = 15,
    };
    char accountName[NAME_LEN];
    char accountPassword[PW_LEN];
    int accountNumber;
    int moneyInAccount;

public :
    void createAccount(const char* newName, const char* newPW, int newAN, int newDeposit);
    void deposit(int depositMoney);
    void showAllInformations();
    
    void changeName(){
        cin >> accountName;
    }
    
    inline void changePassword(){
        cin >> accountPassword;
    }
};

void account::showAllInformations(){
    cout << accountName << endl;
    cout << accountPassword << endl;
    cout << accountNumber << endl;
    cout << moneyInAccount << endl;
}

void account::createAccount(const char* newName, const char* newPW, int newAN, int newDeposit){
    strcpy(accountName, newName);
    strcpy(accountPassword, newPW);
    accountNumber = newAN;
    moneyInAccount = newDeposit;
}

void account::deposit(int money){
    moneyInAccount += money;
}

int main(void){
    account seunghun;
    seunghun.createAccount("seunghun", "1234", 123456, 2100000000);
    seunghun.showAllInformations();
    seunghun.changeName();
    seunghun.showAllInformations();
    seunghun.changePassword();
    seunghun.showAllInformations();
    seunghun.deposit(1);
    seunghun.showAllInformations();
    return 0;
}

seunghun
1234
123456
2100000000
jaehyeon
jaehyeon
1234
123456
2100000000
987654321
jaehyeon
987654321
123456
2100000000
jaehyeon
987654321
123456
2100000001

구조체와 동일하게 작동한다. C++에서 구조체와 클래스의 차이점은 접근제한자의 유무이다. C++에서 클래스의 접근제한자는 다음과 같이 동작한다.

구조체는 접근제한자가 모두 public으로 설정된 클래스와 같다고 볼 수 있다.

Header

#ifndef HEADER_H
#define HEADER_H

//WRITE HEADER CODE HERE

#endif

헤더파일 작성시 헤더파일이 여러번 include되면 코드가 꼬이게된다. 따라서 헤더파일의 중복 include를 피하기위해 헤더파일에 전처리를 해주는것이 일반적이다. 위와같이 전처리를 해주면 해당 헤더파일이 include되었는지 확인 하고 컴파일한다. inline함수는 헤더 내에서 정의되어야한다.

Const

//IN HEADER
void func() const;

//IN CPP
void func() const{
        ...
}

헤더에서 함수를 const로 선언하게되면, 함수는 해당 객체의 멤버변수를 조정할 수 없으며, 내부에서 다른 함수를 호출해서 간접적으로 멤버 변수의 값을 변경할 위험이 있기때문에 함수 내에서 호출 가능한 함수도 const함수로 제한된다. (Read Only)

Constructor, destructor

#include<iostream>

class Player{
private :
    int number;
    int age;
public :
    Player();
    Player(int newNumber);
    Player(int newNumber, int newAge);
    void setNumber(int newNumber);
    void setAge(int newAge);
    void getNumber() const;
    void getAge() const;
    void showInfo() const;
    ~Player();
};

Player::Player(){
    number = 0;
    age = 20;
}

Player::Player(int newNumber){
    number = newNumber;
    age = 20;
}

Player::Player(int newNumber, int newAge){
    number = newNumber;
    age = newAge;
}

Player::~Player(){
    std::cout << "Destructor Called" << std::endl;
}

void Player::setNumber(int newNumber){
    number = newNumber;    
}

void Player::setAge(int newAge){
    age = newAge;
}

void Player::getNumber() const{
    std::cout << "getNumber" << std::endl;
    std::cout << number << std::endl;
    std::cout << "********" << std::endl;
}

void Player::getAge() const{
    std::cout << "getAge" << std::endl;
    std::cout << age << std::endl;
    std::cout << "********" << std::endl;
}

void Player::showInfo() const{
    std::cout << "showInfo" << std::endl;
    std::cout << number << std::endl;
    std::cout << age << std::endl;
    std::cout << "********" << std::endl;
}

int main(void){
    Player A;
    Player B(10);
    Player C(30, 50);
    A.showInfo();
    A.getAge();
    A.getNumber();
    B.showInfo();
    B.setNumber(999);
    C.showInfo();
    C.setAge(999);
    B.showInfo();
    C.getAge();
    A.~Player();
    A.showInfo();
    B.showInfo();
    C.showInfo();
    return 0;
}

50
****
showInfo
999
20
****
getAge
999
****
Destructor Called
showInfo
0
20
****
showInfo
999
20
****
showInfo
30
999
****
Destructor Called
Destructor Called
Destructor Called

생성자 앞에 ~가 붙은게 소멸자가 된다.

This

#include<iostream>

using std::cout;
using std::endl;

class House{
private:
    int squareMeter;
    int level;
public :
    House(){
        squareMeter = 30;
        level = 1;
    }
    House(int newSquare, int newLevel){
        this->squareMeter = newSquare;
        this->level = newLevel;
    }
    void showInfo(){
        cout << "address : " << this << endl;
        cout << "square meter : " << this->squareMeter << endl;
        cout << "level : " << this->level << endl;
    }
};

int main(void){
    House houseA;
    House houseB(100, 4);
    House& houseC = houseB;
    houseA.showInfo();
    houseB.showInfo();
    houseC.showInfo();
    cout << "Manual Address of house A : " << &houseA << endl;
    cout << "Manual Address of house B : " << &houseB << endl;
    cout << "Manual Address of house C : " << &houseC << endl;
    return 0;
}

address : 0x7fff4525cf70
square meter : 30
level : 1
address : 0x7fff4525cf78
square meter : 100
level : 4
address : 0x7fff4525cf78
square meter : 100
level : 4
Manual Address of house A : 0x7fff4525cf70
Manual Address of house B : 0x7fff4525cf78
Manual Address of house C : 0x7fff4525cf78

클래스 내부 에서 this를 사용하면 그 함수가 호출된 객체를 가리킨다.

Self-reference return

#include<iostream>

using std::cout;
using std::endl;

class object{
private : 
    int value;
public :
    object(int newValue){
        this->value = newValue;
    }
    
    object& selfAdd(int operandValue){
        this->value = this->value + operandValue;
        return *this;
    }
    
    void showInfo(){
        cout << "ADDRESS : " << this << endl;
        cout << "VALUE : " << this->value <<endl;
    }
};

int main(void){
    object a(3);
    a.showInfo();
    object& b = a.selfAdd(5);
    a.showInfo();
    b.showInfo();
    a = b.selfAdd(8);
    a.showInfo();
    b.showInfo();
    return 0;
}

ADDRESS : 0x7ffe362b71d4
VALUE : 3
ADDRESS : 0x7ffe362b71d4
VALUE : 8
ADDRESS : 0x7ffe362b71d4
VALUE : 8
ADDRESS : 0x7ffe362b71d4
VALUE : 16
ADDRESS : 0x7ffe362b71d4
VALUE : 16

스스로의 reference를 반환해서 전달할 수 있다.

Copy constructor

#include<iostream>

using std::cout;
using std::endl;

class object{
private : 
    int value;
public :
    object(){
        this->value = 0;
    }
    object(int newValue){
        this->value = newValue;
    }
    object(const object &target){
        this->value = target.value + 1;
    }
    void showInfo(){
        cout<< "adrs : " << this << endl;
        cout<< "vlue : " << this->value<< endl;
    }
};

int main(void){
    object A(3);
    object B = object();
    object C(A);
    object D;
    D = B;
    A.showInfo();
    B.showInfo();
    C.showInfo();
    D.showInfo();
    return 0;
}

adrs : 0x7fff1ee6fb20
vlue : 3
adrs : 0x7fff1ee6fb24
vlue : 0
adrs : 0x7fff1ee6fb28
vlue : 4
adrs : 0x7fff1ee6fb2c
vlue : 0

생성시 다른 객체를 대입하거나, 생성자의 인자로 다른 객체로 넣어주면 복사생성을 할 수 있다. 복사생성은 레퍼런스와 달리 다른 메모리 공간에 객체가 복사되는것이다. 암묵적으로는 단순히 복사가 이뤄지지만, 명시적으로 행위를 추가적으로 정의해줄 수도 있다.

Explicit

#include<iostream>

using std::cout;
using std::endl;

class object{
private :
    int value;
public : 
    explicit object(int newValue){
        value = newValue;
    }
    void showInfo(){
        cout << "adrs : " << this << endl;
        cout << "vlue : " << this->value << endl;
    }
};

int main(void){
    object A(3);                    //NORMAL CONSTRUCTOR
    A.showInfo();
    object B(A);                    //COPY CONSTRUCTOR
    B.showInfo();
    object C = object(10);          //ANOTHER EXPRESSION
    C.showInfo();
    object D = (object)12;          //EXPLICIT
    D.showInfo();
    /*
    object E = 10;                   //IMPLICIT
    E.showInfo();
    */
    return 0;
}

adrs : 0x7ffd89b96010
vlue : 3
adrs : 0x7ffd89b96014
vlue : 3
adrs : 0x7ffd89b96018
vlue : 10
adrs : 0x7ffd89b9601c
vlue : 12

C++에서 생성자는 다양한 방식으로 호출될 수 있는데, 특이하게도 (python 처럼) 변수의 형태로 호출이 가능하다. (암묵적 복사생성) 이런 경우 원하지 않는 값의 자료형으로 객체가 생성되는 경우가 발생할 수 있다. 이를 방지하기위해서 생성자의 앞에 explicit을 붙여주면 암묵적인 생성을 불가능하게 할 수 있다.

다음 글 📚 혼자하는 C++ 공부 -3- 보러가기