자.. 이번 주에는 웹 기획팀으로 첫 출근을 했다 바로 프로젝트에 투입되지 않고 진행 중인 프로젝트의 보조 역할로 일을 배우고 있다. 그러다 스토리보드 회원가입 페이지 수정을 하게 되었는데, 이제 나는 이런 프로세스에 대해서 고민을 해야 하니까 진지하게 고민을 해 봤다.

회원가입을 하며 제공하는 나의 정보들은 지금 사용하려는 서비스에 꼭 필요한 정보일까? 오늘 낮에 배달의 민족을 사용했으니 배달의 민족을 예시로 들겠다.

사실 배달의 민족 회원이 된 시기는 좀 지났기 때문에 내 정보를 어디까지 제공했는지 기억이 잘 안 나지만 확실한 것은 내 번호와 내 주소일 것이다. 배달 현황을 공유하고, 내가 있는 장소로 배달을 받기 위해 제공한 정보다. 내가 제공한 정보만으로도 우아한 형제들은 꽤 괜찮은 데이터를 추출 중일 것이다. 그 데이터를 기반으로 내가 좀 더 나은 서비스를 구성할 수 있을 것이고.

지금이야 이 정보를 어디에 쓰려고 하는지 짐작은 가지만 일반 사용자들은 내 정보를 어디에 쓰려고 하지? 싶은 경험이 있을 것이다. 아무리 명시를 한다고 해도 기억에 잘 안 남기도 하고, 뉴스에서는 개인 정보 노출이라는 헤드라인을 뽑아대니 저절로 개인 정보 제공에 보수적으로 굴 게 된다. 그렇다면 기획자가 제일 먼저 할 수 있는 것은 회원가입의 허들을 낮추는 것이다.

서비스를 위해 필수로 받아야 하는 정보와 꼭 필요한 것은 아니지만 받으면 좋은 정보를 구분한다. 필수 정보와 선택 정보 채널을 따로 만드는 것이다.

배달의 민족 앱 설치 후 최초 화면은 위치 제공 페이지다.

음식을 시켰으니 받아야 하는 위치 제공은 필수다. 이 정보를 제공하지 않으면 배민 서비스를 이용할 수 없다. 그렇지만 당장 내 음식 취향을 배민에 제공한다고 해서 서비스에 지장이 생길까? 그건 아니다. 필수 정보는 주소, 선택 정보는 내 취향이다.

사실 배달의 민족은 가입하지 않아도 서비스를 이용할 수 있다. 배달 현황 공유를 위해 매번 번호 인증을 해야 하긴 하지만 말이다. 서비스 회사 입장에서도 비회원보다 회원의 데이터를 받는 것이 더 이득이기 때문에 (서비스 개선이나 데이터 통계 등) 회원수를 늘리는 것이 목적인데 이러한 회원 전환률을 위해 진행하는 마케팅이 있을 것이다.

비회원 주문을 할 때마다 번거로운 번호 인증 버튼 옆에 로그인을 하면 하지 않아도 된다는 문구나, 편리한 서비스인 배민 페이는 로그인 회원만 할 수 있다는 차별화 전략, 그리고 주문 버튼을 누름과 동시에 로그인하겠냐는 팝업창과 하단에 작게 표시된 비회원 주문하기 버튼이 회원가입을 유도하는 방식이다.

또 하나의 대표적인 마케팅 방식은 첫 주문 시 10000원 할인! 문구가 아닐까 생각한다. 비슷한 예로 친구 초대하고 5000원 할인 받기도 있다. 쿠폰 발급의 조건은 첫 주문자 + 배민 회원이다. 이후 진행하는 모든 쿠폰 이벤트는 회원을 대상으로 진행 중이기도 하다. 배민의 대항마인 요기요도 비슷한 마케팅을 진행했었다. 주문율을 높이기 위한 마케팅도 되지만 회원 전환에도 도움이 되는 마케팅이다.

자 이제 사용자는 회원가입을 하려고 마음 먹었다고 하자. 이제 내가 너희에게 내 정보를 주겠다 생각을 하고 회원 가입 버튼을 눌렀는데 이 번거롭고 어질어질한 회원가입 페이지를 보니 부담스러워서 하기 싫어졌다면 어떻게 해야 할까? 출처 | 이렇게 기획하면 안 돼요! #회원가입

아무래도 스마트폰은 컴퓨터 화면보다 작아서 최대한 간략하게 기획하는 것이 사용자를 배려하는 페이지 기획이다. 우리는 이것을 1 thing 1 page라고 부르기로 했어요.

배달의 민족 회원가입 제일 첫 페이지이다. 1개의 페이지에 1개의 절차를 담았다.

그리고 최대한 간략하게 진행하면 사용자는 번거롭지 않은 회원가입으로 서비스를 누릴 수 있고 필요한 정보만 제공할 수 있어 좋다.

사실 모든 서비스에 정보를 적게 받는 게 좋은 것만은 아니다. 스포티파이, 왓챠와 같은 나만의 취향을 제공하는 큐레이팅 서비스는 회원가입을 하며 취향을 담은 정보를 제공해야 내가 좋아하는 서비스를 누릴 수 있고, 틴더와 같은 데이팅앱도 내가 원하는 조건을 입력해야 개인화된 서비스를 받을 수 있다. 그렇다고 위에 언급한 예시처럼 입력창을 때려 박으라는 뜻은 아니고 오래 걸릴 것 같다면 남은 단계를 눈에 보여줌으로써 사용자가 루즈하지 않도록 유지하는 게 제일 좋을 것이다.

취업을 위해 원티드 서비스를 이용하며 좋았던 것은 이력서 작성 유도와 함께 자신들이 제공하는 이력서로 이력서를 제출하면 서류 통과율이 더 높았다는 메세지와 몇 자 이상 쓰니 멋진 기록을 가지고 있다는 칭찬이 나오니 더 열심히 작성하게 되었다. 내 정보를 받으면 받을 수록 좋은 서비스는 어떤 방식으로 정보를 유도할 것인지도 고민하면 좋을 것 같다.

SwiftUi에서 사용하는 Stack의 종류는 3가지가 있는데 ZStack, HStack, VStack이다.

CS193p를 보며 카드 게임을 만들 수 있는데 제일 먼저 접한 Stack은 ZStack이었다.

ZStack

Gneric Structure, 요소를 오버레이하고 두 축으로 배열하는 뷰.

Text 4개를 겹쳤지만 화면에서는 하나로 보이는 상황. Stack이니 어딘가에 쌓여야 하는데 ZStack이라는 이름에 걸맞게 X, Y, Z 축으로 생각을 해 보면 Z축을 기준으로 Stack이 쌓인다고 보면 된다.

VStack, HStack

Vertical, Horisontal로 쌓이는 Stack이다. 이미지 출처

HStack이랑 VStack은 가로 쌓기, 세로 쌓기의 차이라서 더 서술하지 않으려고 한다.

ScrollView

화면의 Scroll 컨테이너를 쉽게 만들 수 있다. 내부에 배치한 내용에 맞게 자동으로 사이즈 조절이 가능하고, 안전 영역을 피하기 위해 필요한 요소도 자동으로 추가한다.

ScrollView{
    LazyVGrid(columns: [GridItem(.adaptive(minimum: 65))]) {
        ForEach(emojis[0..<emojiCount], id: \.self, content: { 
            emoji in CardView(content: emoji)
                .aspectRatio(2/3, contentMode: .fit)
         })
     }
}

Spacer

이름처럼 빈 공간을 만든다. 다른 Object의 크기에 우선 순위를 두고 해당 오브젝트의 크기가 변하지 않는 선에서 본인의 크기를 최대한 늘리려는 성질이 있다.

HStack {
    remove
    Spacer()
    add
}

가로로 쌓은 Stack을 Spacer()를 넣으니 각각의 버튼이 끝과 끝으로 멀어졌다.

SF-Symbols

위의 이미지에서 사용한 아이콘들은 아이폰 애플리케이션 UI에서 자주 쓰이는 아이콘인데 해당 아이콘을 모아둔 프로그램이 있다.

https://developer.apple.com/sf-symbols/

애플에서 제공하는 프로그램이다.

오른쪽 상단에 원하는 아이콘을 검색하면 여러 아이콘이 나온다.

    var remove: some View {
        Button {
            if emojiCount > 1 { emojiCount -= 1 }
        } label: {
            VStack {
                Image(systemName: "minus.circle") ⬅️
            }
        }
    }
    var add: some View {
        Button {
            if emojiCount < emojis.count { emojiCount += 1}
        } label: {
                VStack {
                     Image(systemName: "plus.circle") ⬅️
            }
        }
    }

⬅️ 표시 위치처럼 Image(systemName: "{sf-symbols 이름}" 으로 부여하면 된다. 사이즈 조절이나 색 부여도 가능하다

ForEach

카드 뒤집기 게임을 만들면서 아이콘 24개를 각 카드마다 부여를 해야 하는데 하나하나 지정하는 방법 말고 반복문을 통해 부여할 수 있다. C를 공부했을 때는 인자를 새로 선언해 반복문을 돌리는 게 번거로웠다면 SwiftUI에서는 스스로 본인 위치에 찾아가는 것 같은 느낌이었다.

일반적인 For과 ForEach가 다른 게 무엇이냐면 ForEach는 일종의 뷰 컨테이너처럼 작용하며, View를 계산해서 보여준다는 점이다.

ForEach(0..<10){ num in
    Text("Num: \(num)")
        .font(.largeTitle)
}

Int값이 아닌 String 배열을 ForEach에 넣으면 어떻게 될까 아마 오류가 날 것이다. 굳이 String이 아닌 Int 배열을 넣어도 똑같이 오류가 날 것.

이유는 Identifiable 프로토콜 조건에 맞지 않는다고 하는데. 해당 조건은 데이터를 식별할 수 있는 무언가를 가지고 있어야 한다고 한다. 각 배열마다 id를 가지고 있어야 한다고 이해하면 되겠다.

그렇다면 이 id는 어떻게 부여해야 할까? 직접 부여하는 방법도 있지만 배열의 개수가 10개 이상이어도 굉장히 귀찮아지는 일이다.

ForEach에서는 배열 내의 각 요소에 id를 부여할 수 있는 방법을 제공하는데

ForEach(emojis[0..<emojiCount], id: \.self, content: { emoji in
    CardView(content: emoji).aspectRatio(2/3, contentMode: .fit)
})

\ .self 를 입력하면 배열에서 각각의 요소에 아이디를 부여한다.

switch문은 조건부 분기 문을 제공한다.

void    testSwitch(int a)
{
    switch(a)
    {
        case 0:
        // do something...
        case 1:
        // do something...
        case 2:
        // do something...
    }
}

switch 표현시기 값을 평가하고, 각 case의 값과 같은지 테스트하고 같을 경우 해당 case안의 코드를 실행한다.

간단하게.. a가 a==0이면 case0부터 case2까지 실행할 수 있는 (break가 있으면 멈춤) 개꿀 함수가 되겠다.

main.cpp를 인자를 받는 식으로 바꾸고 해당 값과 ex05에서 한 것처럼 반복문을 통해 같은 level을 만나면 이후에 주어진 포인터의 level도 연속으로 실행을 한다.

int    flag = 0;
    for(int i = 0; i < 4; i++)
    {
        if (levels[i] == level)
        {
            switch (i)
            {
                case 0:
                        (this->*funcs[0])();
                        flag++;
                case 1:
                        if (i != 1)
                            std::cout << std::endl;
                        (this->*funcs[1])();
                        flag++;
                case 2:
                        if (i != 2)
                            std::cout << std::endl;
                        (this->*funcs[2])();
                        flag++;
                case 3:
                        if (i != 3)
                            std::cout << std::endl;
                        (this->*funcs[3])();
                        flag++;
            }
        }
    }
    if (flag == 0)
        std::cout << "[ Probably complaining about insignificant problems ]" <<std::endl;

void    (Karen::*funcs[4])(void) = {
    &Karen::debug,
    &Karen::info,
    &Karen::warning,
    &Karen::error
};
std::string levels[4] = {
    "DEBUG",
    "INFO",
    "WARNING",
    "ERROR"
};

반복문을 통해levels[i] == level일 때(this->*funcs[i])()를 실행하면 된다.

fstream 헤더는 c++에서의 파일 입출력 헤더이다.std::cout, std::cin과 유사하게 시프트 연산을 통해 사용할 수 있다.

fstream 헤더에는 총 세 가지 클래스가 존재한다.

1. ifstream
2. ofstream
3. fstream

1. 파일 불러오기

std::ifstream fin(filename);
    //파일 연결
    if (fin.fail())
    {
        std::cerr << "Error: No '" << filename << "' found" << std::endl;
        return (1);
    }

2. 파일 내용 출력해 보기

char out;
    while (fin.get(out))
        std::cout << out;

3. s1문자열이 있는지 확인하기

while (buf.find(s1) != std::string::npos)

4. s1 내용을 s2 내용으로 바꾸기

{
    index = buf.find(s1);
    buf.erase(index, s1.length());
    //s1지우고
    buf.insert(index, s2);
    //s2넣기
}

5. 해당 파일을 .replace 확장자 붙여서 출력하기

std::ofstream fout(filename + ".replace");
fout << buf;

해당 과제에서는 main문이 주어진다. == main을 보고 필요함 함수를 파악해야 한다.

• club 객체의 setType 함수를 사용해도 Human 객체가 지니고 있는 Weapon의 type이 변경되므로, Human 클래스 내의 Weapon은 생성자는 setWeapon 함수를 통해 들어온 Weapon 객체가 저장된 메모리를 참조할 수 있어야 한다.
• Human 클래스 내의 Weapon은 포인터나 참조자로 선언한다.
• 과제 규칙 중 HumanB는 Weapon이 NULL일 수도 있다는 의미이로 HumanB는 포인터로 선언.
• club은 포인터 변수가 아니며, HumanA 생성자의 두번째 매개변수로 객체 자체를 받기 때문에 HumanA는 참조자로 선언한다.

HumanA, HumanB에서 사용하는 Weapon을 꺼내지 않고 setType을 통해 A, B에 저장된 Weapon 값이 변경되어야 한다.

setWeapon()나 HumanA 생성자에서는 포인터를 사용하지 않았으니 참조를 사용하고, HumanB는 weapon 타입 클래스 변수가 NULL이어야 하며, setWeapon을 통해 클래스를 세팅하기 때문에 포인터를 사용하였다.

HumanA에서 참조 변수를 초기화할 필요가 있을 경우 초기화 리스트를 사용한다.

초기화 리스트

HumanA::HumanA(std::string name, Weapon &weapon)
{
    this->name = name;
    this->weapon = weapon;
}

해당 내용으로 컴파일을 하면 오류가 난다.

선언과 동시에 초기화해야 한다는 참조자의 제약 사항이 있기 때문. 또한 참조 변수가 아니어도 Class가 const로 선언되었다면 같은 오류가 발생할 것이다. 기존에 사용하는 방식은 선언 후 대입하는 방식에 가깝기 때문에 밑의 내용과 같이 수정했다.

HumanA::HumanA(std::string name, Weapon &weapon) : name(name), weapon(weapon)
{
}

변수는 할당된 메모리 공간에 붙여진 이름이다. 우리는 변수의 이름을 가지고 해당 메모리 공간에 접근이 가능하다. 참조자는 할당된 하나의 메모리 공간에 다른 이름을 붙이는 것을 말한다. 자신이 참조하는 변수를 대신할 수 있는 별명과 같은 것이다.

std::string    str = "HI THIS IS BRAIN";
std::string    *stringPTR = &str;
std::string    &stringREF = str;

std::cout << "str = " << str << std::endl;
std::cout << "stringPTR = " << *stringPTR << std::endl;
std::cout << "stringREF = " << stringREF << std::endl;
stringREF = "HI THIS IS NOT BRAIN";
std::cout << "====================value change====================" << std::endl;
std::cout << "str = " << str << std::endl;
std::cout << "stringPTR = " << *stringPTR << std::endl;
std::cout << "stringREF = " << stringREF << std::endl;

stringREF은 str의 별명이며 같은 메모리 공간을 참조한다. 참조자를 통해 값을 변경하면 메모리 공간을 같이 쓰는 변수의 값도 변경된다.

참조자와 포인터

참조자와 포인터는 유사한 점이 많은데, 참조자는 포인터를 잘못 사용해서 생길 수 있는 문제를 줄이기 위한 대안이며, 포인터보다 제약사항이 많다고 한다.

• 포인터는 초기화 없이 선언이 가능하며, NULL로 초기화가 가능하다
• 참조자는 둘 다 불가능하다. 따라서 널 포인터 역참조 같은 문제를 사전에 방지할 수 있다.
• 또한 참조 대상의 주소에 접근할 수 있을 뿐, 참조 대상의 주소 자체를 바꾸는 것은 불가능하기 때문에 초기화된 이후로 참조대상을 변경할 수 없다.

int    main()
{
    std::string    str = "HI THIS IS BRAIN";
    std::string    *stringPTR = &str;
    std::string    &stringREF = str;

    std::cout << "=============================" << std::endl;
    std::cout << "           STRING            " << std::endl;
    std::cout << "=============================" << std::endl;
    std::cout << "str = " << str << std::endl;
    std::cout << "stringPTR = " << *stringPTR << std::endl;
    std::cout << "stringREF = " << stringREF << std::endl;
    std::cout << "=============================" << std::endl;
    std::cout << "           ADDRESS           " << std::endl;
    std::cout << "=============================" << std::endl;
    std::cout << "str = " << &str << std::endl;
    std::cout << "stringPTR = " << stringPTR << std::endl;
    std::cout << "stringREF = " << &stringREF << std::endl;
}

객체를 배열 넣는 방법은 두 가지가 있는데 객체 배열과 객체 포인터 배열이다.

// 객제 배열 선언
Zombie Zombies[10];
// 객체 포인터 배열 선언
Zombie *Zombies = new Zombie[10];

객체 배열

객체 배열 선언 시 생성자도 호출되지만 생성자에 인자를 전달하지 못한다. 원하는 값으로 초기화가 필요하다면 초기화 과정이 따로 필요하다. 객체 배열 생성 시 생성자가 호출되는 것이 확인된다, 배열 소멸 시 소멸자도 호출.

객체 포인터 배열

객체의 주소를 담는 방식. 선언 후 일일히 동적할당하여 반환된 객체의 주소값을 배열에 대입해 줘야 함.

zombieHorde 함수

N개의 Zombie를 한 번에 할당해야 하며 한 번에 삭제되어야 한다. 주소를 반환하라고 하지 않았으니 객체 배열로 만든다.

ex00에 사용한 함수를 그대로 재활용해도 된다는 조건에 추가 작업할 시간은 줄었는데 함수를 작성하고 보니 name이 그대로 사용되어 구분이 어려웠다.

C에서 사용한 atoi처럼 c++에도 방법이 있을 것이라 판단해 찾아 보았다 itos라는 함수가 있었는데 해당 함수는 버전이 높아 지금 상황에서는 쓸 수 없었다. 직접 만들거나 다른 방법을 찾아야 했는데 블로그를 발견해 해당 방법을 찾았다

Zombie* zombieHorde( int N, std::string name )
{
    Zombie    *numzom = new Zombie[N];
    std::stringstream    ss;

    for (int i = 0; i < N; i++)
    {
        ss << i;
        numzom[i].setName(name + ss.str());
        numzom[i].announce();
        ss.str("");
    }
    return (numzom);
}

방법은 간단하다. i로 들어온 int 값을 ss에 넣고, 해당 값을 str()형식으로 출력해 setName으로 name을 변경한다.

기본 생성자를 통해 인스턴스를 만들기 위해 기본 생성자를 명시했다.

zombieHorde에서 값을 초기화하지 않고 계속 값을 추가했더니 이렇게 됐다. 함수 사용에는 문제가 없지만 보기에 좋지 않아서 사용이 끝나면 초기화하는 방식으로 ss.str(""); 을 작성했다. stringstream 사용법을 보며 clear()가 있어서 해당 함수가 초기화라고 생각했는데 state를 지우는 함수라고 했다. stringstream를 초기화하는 함수는 2개가 있다.

1. ss.str("");
2. ss.str(std::string());

이제 예쁘게 잘 나온다.

Setter

void    Zombie::setName(std::string name)
{
    this->name = name;
}

ex00의 조건 중에는 name을 private로 선언해야 했는데 zombieHorde 에서 Zombie 클래스의 name을 변경하는 것이 불가능하기 때문에 private로 선언된 변수를 변경하기 위해서는 클래스 내부에서 접근할 수 있는 public 함수로 새로 선언해야 한다. 이러한 것을 setter라고 부른다.

그렇다면 private가 아닌 public으로 선언하면 되는데 굳이 setter를 이용하는 이유는 무엇일까? CPP00에도 적었지만 외부에서 무분별하게 변수의 값을 설정하는 것을 막기 위해서다. setter를 통해 접근하면 예외처리가 가능하지만 변수로 바로 접근한다면 예외처리가 불가능하기 때문.

Zombie stackZombie = Zombie("stackZombie");
Zombie *heapZombie = newZombie("heapZombie");

1번은 stack에 할당, 2번은 heap에 할당하는 방식이다. heap에 할당하고 싶다면 new예약어와 포인터 변수를 사용하면 된다

stack과 heap을 익히기 전 메모리 구조에 대해 알면 더 좋다. 프로그램이 실행되기 위해서는 프로그램이 메모리에 로드가 되어야 하며, 프로그램에서 사용되는 변수들을 저장할 메모리도 필요하다.

따라서 컴퓨터의 운영체제는 프로그램의 실행을 위해 다양한 메모리 공간을 제공한다. 프로그램이 운영체제로부터 할당 받는 대표적인 메모리 공간은 4가지다.

1. code, 2. data, 3. stack, 4. heap

code

실행할 프로그램의 코드가 저장되는 영역이다. text영역이라고도 함. CPU는 코드 영역에 저장된 명령어를 하나씩 가져가서 처리함.

data

프로그램의 전역 변수와 정적 변수가 저장되는 영역이다. 데이터 영역은 프로그램의 시작과 함께 할당되며 프로그램이 종료되면 소멸한다.

stack

함수의 호출과 관계되는 지역 변수와 매개변수가 저장된다.

stack영역은 함수의 호출과 함께 할당되며, 함수의 호출이 완료되면 소멸한다. stack에 저장되는 함수의 호출 정보를 stack frame이라고 함.

stack영역은 push로 데이터를 저장하고, pop으로 데이터를 인출한다. 이러한 stack은 후입선출 방식에 따라 동작하기 때문에 가장 늦게 저장된 데이터가 가장 먼저 pop된다.

stack영역은 메모리의 높은 주소에서 낮은 주소의 방향으로 할당됨.

런타임 시점에서 크기가 결정된다

LIFO 구조이다 (LIFO == 후입선출 Last In, First Out)

선언한 함수 영역을 벗어나면 자동으로 소멸

. 연산자를 통해 접근

heap

사용자가 직접 관리할 수 있고, 그래야만 하는 메모리 영역이다. 사용자에 의해 메모리 공간이 동적으로 할당되고 해제된다.

heap영역은 메모리의 낮은 주소에서 높은 주소의 방향으로 할당된다.

컴파일 시점에서 크기가 결정된다

동적 메모리 할당을 통해 저장되는 영역

힙 영역은 모든 프로세스에서 동적으로 로드된 모듈에서 공유된다

-> 연산자를 통해 인스턴스에 접근

사용이 종료된 시점에서 할당을 해제하지 않으면 메모리 릭이 발생

stack과 heap의 장단점

stack

• 매우 빠른 엑세스
• 변수를 명시적으로 할당 해제하지 않아도 된다
• 공간은 cpu에 의해 효율적으로 관리되며 메모리는 단편화 되지 않는다.
• 지역 변수만 사용한다
• stack 크기가 os에 따라 제한된다
• 변수의 크기를 조정할 수 없다

heap

• 변수를 전역적으로 액세스 할 수 있다
• 메모리 크기 제한 없다
• 상대적으로 느린 액세스
• 호율적인 공간 사용을 보장하지 못하면 메모리 블록이 할당된 후 시간이 지남에 따라 메모리가 조각화되어 해제될 수 있다
• 메모리를 직접 관리해야 한다(변수 할당, 해제는 직접)
• c에서는 realloc, c++에서는 new (java도 new)

newZombie vs randomChump

newZombie 함수는, 다른 곳에서도 생성한 좀비 인스턴스를 사용할 수 있어야하므로 힙영역에 인스턴스를 생성하는 것이 적절하고, randomChump 함수 같은 경우는 함수 내에서 인스턴스가 자신의 역할을 전부 수행하기 때문에 스택영역에 할당해도 무방하다.

main.cpp

const    std::string NAME[] =
{
    "zombie00",
    "zombie01",
    "zombie02",
    "zombie03"
};

int    main(void)
{
    Zombie stackZombie = Zombie("stackZombie");

    Zombie *heapZombie = newZombie("heapZombie");
    delete heapZombie;

    for (int i = 0; i < 4; i++)
    {
        randomChump(NAME[i]);
    }
}

1. stackZombie는 stack에 할당되었기 때문에 따로 해제를 하지 않아도 프로그램 종료와 함께 소멸한다
2. heapZombie는 heap에 할당되었으며 delete heapZombie 으로 직접 소멸을 명령했다
3. 반복문으로 randomChump 함수를 실행시켰으며 1번과 같이 stack 영역에 할당해 함수 내 인스턴스가 자신의 역할을 모두 수행했기 때문에 자동으로 소멸된다.

Account.hpp

// ************************************************************************** //
//                                                                            //
//                Account.hpp for GlobalBanksters United                //
//                Created on  : Thu Nov 20 19:43:15 1989                      //
//                Last update : Wed Jan 04 14:54:06 1992                      //
//                Made by : Brad "Buddy" McLane <bm@gbu.com>                  //
//                                                                            //
// ************************************************************************** //

#pragma once
#ifndef __ACCOUNT_H__
#define __ACCOUNT_H__

// ************************************************************************** //
//                               Account Class                                //
// ************************************************************************** //

class Account {

public:

    typedef Account        t;

    static int    getNbAccounts( void );
    static int    getTotalAmount( void );
    static int    getNbDeposits( void );
    static int    getNbWithdrawals( void );
    static void    displayAccountsInfos( void );

    Account( int initial_deposit );
    ~Account( void );

    void    makeDeposit( int deposit );
    bool    makeWithdrawal( int withdrawal );
    int        checkAmount( void ) const;
    void    displayStatus( void ) const;

private:

    static int    _nbAccounts;
    static int    _totalAmount;
    static int    _totalNbDeposits;
    static int    _totalNbWithdrawals;

    static void    _displayTimestamp( void );

    int                _accountIndex;
    int                _amount;
    int                _nbDeposits;
    int                _nbWithdrawals;

    Account( void );

};

// ************************************************************************** //
// vim: set ts=4 sw=4 tw=80 noexpandtab:                                      //
// -*- indent-tabs-mode:t;                                                   -*-
// -*- mode: c++-mode;                                                       -*-
// -*- fill-column: 75; comment-column: 75;                                  -*-
// ************************************************************************** //

#endif /* __ACCOUNT_H__ */

test.cpp

// ************************************************************************** //
//                                                                            //
//                tests.cpp for GlobalBanksters United                        //
//                Created on  : Thu Nov 20 23:45:02 1989                      //
//                Last update : Wed Jan 04 09:23:52 1992                      //
//                Made by : Brad "Buddy" McLane <bm@gbu.com>                  //
//                                                                            //
// ************************************************************************** //

#include <vector>
#include <algorithm>
#include <functional>
#include "Account.hpp"

int        main( void ) {

    typedef std::vector<Account::t>                              accounts_t;
    typedef std::vector<int>                                  ints_t;
    typedef std::pair<accounts_t::iterator, ints_t::iterator> acc_int_t;

    int    const                amounts[]    = { 42, 54, 957, 432, 1234, 0, 754, 16576 };
    size_t const            amounts_size( sizeof(amounts) / sizeof(int) );
    accounts_t                accounts( amounts, amounts + amounts_size );
    accounts_t::iterator    acc_begin    = accounts.begin();
    accounts_t::iterator    acc_end        = accounts.end();

    int    const            d[]            = { 5, 765, 564, 2, 87, 23, 9, 20 };
    size_t const        d_size( sizeof(d) / sizeof(int) );
    ints_t                deposits( d, d + d_size );
    ints_t::iterator    dep_begin    = deposits.begin();
    ints_t::iterator    dep_end        = deposits.end();

    int    const            w[]            = { 321, 34, 657, 4, 76, 275, 657, 7654 };
    size_t const        w_size( sizeof(w) / sizeof(int) );
    ints_t                withdrawals( w, w + w_size );
    ints_t::iterator    wit_begin    = withdrawals.begin();
    ints_t::iterator    wit_end        = withdrawals.end();

    Account::displayAccountsInfos();
    std::for_each( acc_begin, acc_end, std::mem_fun_ref( &Account::displayStatus ) );

    for ( acc_int_t it( acc_begin, dep_begin );
          it.first != acc_end && it.second != dep_end;
          ++(it.first), ++(it.second) ) {

        (*(it.first)).makeDeposit( *(it.second) );
    }

    Account::displayAccountsInfos();
    std::for_each( acc_begin, acc_end, std::mem_fun_ref( &Account::displayStatus ) );

    for ( acc_int_t it( acc_begin, wit_begin );
          it.first != acc_end && it.second != wit_end;
          ++(it.first), ++(it.second) ) {

        (*(it.first)).makeWithdrawal( *(it.second) );
    }

    Account::displayAccountsInfos();
    std::for_each( acc_begin, acc_end, std::mem_fun_ref( &Account::displayStatus ) );

    return 0;
}

// ************************************************************************** //
// vim: set ts=4 sw=4 tw=80 noexpandtab:                                      //
// -*- indent-tabs-mode:t;                                                   -*-
// -*- mode: c++-mode;                                                       -*-
// -*- fill-column: 75; comment-column: 75;                                  -*-
// ************************************************************************** //

Account.cpp

void    Account::_displayTimestamp(void)
{
}

void Account::displayAccountsInfos()
{
}

Account::Account(int initial_deposit)
{
}

void    Account::displayStatus( void ) const
{
}

void Account::makeDeposit( int deposit )
{
}

bool Account::makeWithdrawal( int withdrawal )
{
}

Account::~Account()
{
}

hpp에 선언된 함수들이 test.cpp에서 어떻게 출력이 되는지 확인하기 위해 함수 선언만 냅다 넣은 후 cmd 로그를 출력했다.

이제 저 함수 순서에 맞게 log 파일을 비교하며 만들 것이다.

void    Account::_displayTimestamp(void)
{
    time_t    t_stamp;
    char    buff[16];

    time(&t_stamp);
    strftime(buff, sizeof(buff), "%Y%m%d_%H%M%S", localtime(&t_stamp));
    std::cout << "[" << buff << "]";
}

log파일에 있는 시간 그대로 출력해야 하는 건가? 싶었는데 그냥 프로그램 실행 시간을 출력하면 돼서 ctime의 함수인 time()을 활용하기로 했다. time_t 구조체(시간을 다루는데 필요한 정보가 저장됨)에 time()으로 초 단위의 시간을 부여하고, strftime()으로 원하는 출력 양식으로 표현할 수 있다. 해당 함수로 time_t를 지정한 양식으로 변환시켜주는 기능이다. (참고) localtime()으로 초 단위의 시간을 현재 시간으로 출력했다.

Account::Account(int initial_deposit)
{
    _accountIndex = Account::_nbAccounts;
    _amount = initial_deposit;
    _nbDeposits = 0;
    _nbWithdrawals = 0;
    _displayTimestamp();
    std::cout << " index:" << _accountIndex << ";";
    std::cout << "amount:" << _amount << ";";
    std::cout << "created" << std::endl;
    Account::_nbAccounts++;
    Account::_totalAmount += _amount;
}

log의 제일 첫 부분을 담당한다. 정보들을 생성했음을 알리는 함수다.

void Account::displayAccountsInfos()
{
    _displayTimestamp();
    std::cout << " accounts:" << Account::_nbAccounts << ";";
    std::cout << "total:" << Account::_totalAmount << ";";
    std::cout << "deposits:" << Account::_totalNbDeposits << ";";
    std::cout << "withdrawals:" << Account::_totalNbWithdrawals << std::endl;
}

[20220103_011945] accounts:8;total:20049;deposits:0;withdrawals:0 으로 중간 집계 느낌으로 출력되는 내용이 있다. 어.. getter로 접근하라는 것 같았지만 까먹었다..^^!

void Account::makeDeposit( int deposit )
{
    int    p_amount;

    p_amount = _amount;
    _amount += deposit;
    _nbDeposits++;
    _displayTimestamp();
    std::cout << " index:" << _accountIndex << ";";
    std::cout << "p_amount:" << p_amount << ";";
    std::cout << "deposits:" << deposit << ";";
    std::cout << "amount:" << _amount << ";";
    std::cout << "nb_deposits:" << _nbDeposits << std::endl;
    Account::_totalNbDeposits++;
    Account::_totalAmount += deposit;
}

deposit 값이 들어오면서 amount 값에 변동이 생겼다. 인덱스; 금액; 예치금; 금액 + 예치금; 예치금 횟수; 로 이해했으니 새로운 인자 p_amount을 선언해 함수를 만들었다. displayAccountsInfos에서 활용하기 위해 total인자도 값을 부여.

bool Account::makeWithdrawal( int withdrawal )
{
    int    p_amount;

    p_amount = _amount;
    _amount = _amount - withdrawal;
    _displayTimestamp();
    std::cout << " index:" << _accountIndex << ";";
    std::cout << "p_amount:" << p_amount << ";";
    if (_amount >= 0)
    {
        _nbWithdrawals++;
        std::cout << "withdrawal:" << withdrawal << ";";
        std::cout << "amount:" << _amount << ";";
        std::cout << "nb_withdrawals:" << _nbWithdrawals << std::endl;
        _totalNbWithdrawals++;
        Account::_totalAmount -= withdrawal;
        return (true);
    }
    else
    {
        std::cout << "withdrawal:refused" << ";" << std::endl;
        _amount = p_amount;
        return (false);
    }
}

인덱스; 원금; 회수액; 원금 - 회수액; 회수 횟수; 함수 선언이 boolen으로 되어있고, 원금 - 회수액이 0보다 클 때, 작을 때의 출력 문구도 다르기 때문에 조건문으로 각 반환 값을 true, false로 나눴다.

Account::~Account()
{
    _displayTimestamp();
    std::cout << " index:" << _accountIndex << ";";
    std::cout << "amount:" << _amount << ";";
    std::cout << "closed" << ";" << std::endl;
}

모든 프로그램을 마무리 하는 함수다. 남은 금액을 출력하면 돼서 생각한대로 출력을 했지만

예시로 받은 log와 출력 값이 달라서 살짝 멘붕이었다. 슬랙과 여러 블로그를 보며 이유를 알 수 있었는데. 간단히 설명하면 시스템 사양이 달라서, 설명을 곁들이자면 맥에서는 vector 안에서의 소멸 순서는 vextor가 구현된 표준 라이브러리에 따라 다르기 때문이다. 까먹지 말고 평가할 때 말해야겠다..

• Exercise01 : My Awesome PhoneBook

  다음과 같은 조건을 만족하는 전화번호부 프로그램을 작성하라.

  • 동적 할당을 하지 않고 최대 8개의 연락처를 저장할 수 있다.

  • 프로그램의 명령은 EXIT, ADD, SEARCH만 인식하며, 그 외의 경우는 모두 무시한다.

  • EXIT프로그램이 종료되며 모든 연락처가 삭제된다.

  • ADD연락처의 모든 정보가 채워질 때 까지 표준입력을 통해 정보를 입력받는다.

    • 연락처의 정보는 : first name, last name, nickname, phone number, darkest secret으로 구성되어 있다.
    • 전화번호부 클래스는 연락처 배열을 포함해야 한다.
    • 연락처는 반드시 코드에서 클래스의 인스턴스로 구현되어야 한다.
    • 만약 전화번호부에 8개의 연락처가 모두 차 있는 경우, 가장 마지막에 있는 연락처를 지우고 새로운 연락처를 해당 인덱스에 넣어야 한다.

  • SEARCH전화번호부 프로그램은 비어있지 않은 연락처의 4개 열을 출력한다 : index, first name, last name, nickname

    • 각 열의 너비는 10글자이며, 우측 정렬이고, 각 열은 | 기호로 분리된다. 또한 10글자를 초과한 항목의 경우 항목 + .을 10글자 길이로 맞추어 출력한다.
    • index를 추가로 입력할 시 해당 연락처의 모든 정보를 출력한다. 입력이 이상할 경우 특정 동작을 정의해야 한다.

    해당 과제에서는 클래스라는 새로운 개념을 학습해야 한다.

Class

구조체 선언과 마찬가지로 클래스 선언은 메모리에 할당되지 않는다. 클래스가 어떻게 보이는지만 정의한다. 클래스를 사용하려면 해당 클래스 타입의 변수를 선언해야 한다.

데이터를 보유하는 것 외에도 클래스에는 함수가 포함될 수 있다. 클래스 내부에 선언된 함수를 멤버 함수라고 한다 == 메소드라고 불리기도 한다. 멤버 함수는 클래스 정의의 내부 또는 외부에서 정의할 수 있다. 해당 예제는 내부에 정의.

struct DateStruct 
{ 
    int year; 
    int month;
    int day; 
};

class DateClass 
{ 
    public:
        int m_year; 
        int m_month;
        int m_day; 

    void print()
    { 
        std::cout << m_year << "/" << m_month << "/" << m_day; 
    }
};

int main() 
{ 
    DateClass birthDay { 2019, 7, 28 }; 

    birthDay.m_year = 1992; // 클래스의 멤버 변수 접근, 값 수정 
    birthDay.print(); // 클래스의 멤버 함수 호출 return 0; 
}

구조체의 멤버처럼 클래스의 멤버는 멤버 선택 연산자 . 를 통해 접근할 수 있다.

DateClass.printf()를 호출하면 m_year을 DateClass.m_year로 해석한다. 연관된 객체가 암시적으로 멤버 함수에 전달이 되는 것을 암시적 개체라고 한다.

멤버 함수가 항상 작업할 클래스의 암시적 객체를 가지고 있다는 것이 중요

접근지정자

• private : 클래스 내부에서만 접근 가능.
• public : 클래스 내부뿐만 아니라 외부에서도 접근 가능.

해당 클래스를 제외한 클래스, 해당 클래스 멤버 함수를 제외한 다른 함수를 의미한다. 만약 클래스 외부에서 private 으로 선언된 변수에 접근하고 싶다면 getter, setter 함수를 이용해야한다. private 로 선언하는 것은 정보를 감추거나 무분별한 변수의 값 변경을 막기 위해.

생성자(Constructor)

클래스의 모든 멤버 변수가 public인 경우 초기화 목록 또는 유니폼 초기화를 사용해 초기화할 수 있다. 그러나 멤버 변수가 private 인 경우에는 변수에 직접 접근할 수 없는 비공개 상태이므로 더는 위와 같은 방법으로는 클래스를 초기화할 수 없다.

생성자는 해당 클래스의 객체가 인스턴스화될 때 자동으로 호출되는 특수한 종류의 멤버 함수. 일반적으로 클래스의 멤버 변수를 적절한 기본값 또는 사용자 제공 값으로 초기화하거나 클래스를 사용하는 설정이 필요한 경우 사용된다.

생성자 정의 방법 규칙

• 생성자 이름은 클래스와 이름이 같아야 한다
• 생성자는 리턴 타입이 없다 (void도 아니다)

class ClassName
{
public:
    int i;
    int j;
    ClassName()
    {
        std::cout << "생성자 테스트 문구입니다\n";
    };
    ClassName(int i, int j)
    {
        //code
    };
    ClassName(int i)
    {
        //code
    };
    ClassName(int j)
    {
        //code
    };
    ~ClassName();
};

class 선언 후 class명과 같은 이름의 생성자를 정의한다. 생성자는 여러 개의 매개변수를 가질 수 있고, 오버로딩을 지원하기 때문에 위와 같이 선언할 수 있다.

~Contact()

디폴트 생성자 앞에 ~을 붙인 형태. 매개 변수가 없다.

인스턴스의 사용이 끝나고 소멸될 때(메모리 반환) 자동으로 호출되는 코드

int main()
{
    ClassName name;
    ClassName *pName = new Name;
    return 0;
}

//=====[output]=====//
>> 생성자 테스트 문구입니다
>> 생성자 테스트 문구입니다

참고

프로그램 규칙

1. 프로그램은 사용자의 커맨드 입력을 대기하고 있다.
2. 유효한 명령은 EXIT, ADD, SEARCH 3가지이다.
   • EXIT : 프로그램 종료
   • ADD : Contact의 필드를 하나씩 입력받아, PhoneBook에 Contact를 하나 추가(연락처의 저장은 최대 8개까지 가능하며, 8개를 넘으면 가장 오래전에 저장된 연락처가 삭제)
   • SEARCH : index를 입력받아 해당 index에 대응되는 연락처를 출력
3. 명령이 실행된 이후에는 다른 명령어 입력을 대기하고 있다.

Phonebook.cpp

int    main(void)
{
    std::string    cmd;
    Contact contact;

    std::cout << "📞 Hello~ This is soooh Phonebook" << std::endl;
    std::cout << "Save Contact   : ADD"<< std::endl;
    std::cout << "Search Contact : SEARCH"<< std::endl;
    std::cout << "Contact End    : EXIT"<< std::endl;
    while (true)
    {
        std::cout << "COMMAND        : ";
        std::cin >> cmd;
        if (cmd == "ADD")
            contact.Add();
        else if (cmd == "SEARCH")
            contact.Search();
        else if (cmd == "EXIT")
            return (0);
        else
            std::cout << "===== Wrong input =====" << std::endl;
        std::cin.clear();
        std::cin.ignore(1000, '\n');
        if (std::cin.eof())
            return (0);
    }
}

EXIT 입력하거나 eof 데이터가 없을 때까지 반복문 cin으로 입력 받으려고 할 때 EOF(End Of File)이라면 입력이 취소되며 이때 반환값은 true이다. 이를 이용해 파일이 종료될 때까지 입력 받는 코드를 작성할 수 있다. (터미널에서는 수동 입력으로 해야 함 ctrl + D) 참고

cin을 통해 문자와 숫자를 입력 받을 때 저장되는 방식이 다르다.

문자: 입력 버퍼에 저장 후 해당 값을 읽어 변수에 저장 숫자: 바로 변수에 저장 (버퍼가 필요없음)

예를 들어 숫자를 입력 받아 변수에 입력하는 도중에 문자가 입력되면 해당 버퍼에 저장이 되면 버퍼에 저장된 값이 정수형 변수에 저장하려고 하기 때문에 failbit를 설정해 버퍼에 값이 계속 남고 해당 함수를 예시로 들자면 ===== Wrong input ===== 이 반복적으로 나오게 된다.

cin.clear()를 통해 에러비트를 초기화하고, cin.ignore()를 통해 두 번째 인자인 개행으로 버퍼를 계속 비워주겠다는 뜻이다.

contact.cpp

void    Contact::Add()
{
    int    i;
    if (index == 8)
    {
        for(i = 1; i < index; i++)
            book[i - 1] = book[i];
        index--;
    }
    std::cout << "first name : ";
    std::cin >> book[index].first_name;
    std::cout << "last name : ";
    std::cin >> book[index].last_name;
    std::cout << "nickname : ";
    std::cin >> book[index].nickname;
    std::cout << "phone number : ";
    std::cin >> book[index].phone_number;
    std::cout << "darkest secret : ";
    std::cin >> book[index].darkest_secret;
    index++;
}

연락처는 최대 8 개까지 저장할 수 있고, 추가로 저장을 할 때 제일 최근에 저장된 연락처가 사라진다. 연락처의 갯수가 8 개라면 반복문을 통해 해당 번호의 앞 번호로 다시 저장 후 연락처를 저장한다.

std::string    LengthCheck(std::string str)
{
    if (str.length() >= 10)
    {
        str = str.substr(0, 9);
        str += ".";
    }
    return (str);
}

void    Contact::Search()
{
    int    i;

    i = 0;
    std::cout << "|";
    std::cout << std::setw(10) << "INDEX" << "|";
    std::cout << std::setw(10) << "First name" << "|";
    std::cout << std::setw(10) << "Last name" << "|";
    std::cout << std::setw(10) << "Nickname" << "|" << std::endl;
    for(i = 0; i < index; i++)
    {
        std::cout << "|";
        std::cout << std::setw(10) << i + 1 << "|";
        std::cout << std::setw(10) << LengthCheck(book[i].first_name) << "|";
        std::cout << std::setw(10) << LengthCheck(book[i].last_name) << "|";
        std::cout << std::setw(10) << LengthCheck(book[i].nickname) << "|" << std::endl;;
    }
    std::cout << "Enter the index of the name : ";
    std::cin >> i;
    i--;
    if (index == 0)
        std::cout << "oh.. Phonebook is empty" << std::endl;
    else if (i < index && i > 0)
    {
        std::cout << "Fist name      : " << book[i].first_name << std::endl;
        std::cout << "Last name      : " << book[i].last_name << std::endl;
        std::cout << "Nickname       : " << book[i].nickname << std::endl;
        std::cout << "PhoneNumber    : " << book[i].phone_number << std::endl;
        std::cout << "Darkest Secret : " << book[i].darkest_secret << std::endl;
    }
}

서브젝트 규정 중 연락처를 출력하는데 있어서 한정된 크기를 부여 받았고 해당 조건을 충족하기 위해 setw(크기)를 사용했다. setw()는 매개 변수만큼 공간을 잡고 그 공간에 내용을 출력한다.

ex) std::setw(10) << “a” ⇒ | a| 10칸 확보 후 “a”를 출력.

연락처의 내용이 10 글자 이상일 때 9개만 출력 후 .으로 대체하는 조건이 있었다. str.substr()으로 해당 문자열의 0부터 9번째의 글자만 출력하고 다음에 .을 출력하도록 했다.

[C++ 의 표준출력 std::cout 의 연습]

to_upper 프로그램 만들기

• 제출할 디렉토리: ex00/
• 제출할 파일: Makefile, megaphone.cpp
• 금지 함수: 없음

다음과 같은 동작을 하는 프로그램을 쓰세요

• 대문자로 바꾸기
• if (argc == 1) 출력 * LOUD AND UNBEARABLE FEEDBACK NOISE *
• 출력시 argv 간 띄어쓰기 추가하지 않음
• 마지막줄 개행

과제를 작성하기 전 C++의 표준 입출력을 알아야 한다.

1. C++ 표준 입출력

#include <iostream>

int main()
{
  std::cout << "Hello, World!!" 
    std::cout << std::endl;
  return (0);
}

C에서 사용한 stdio.h와 달린 C++에서는 iostream를 사용한다. .h를 안 붙인다는 차이가 있으며 함수 작성에 가장 기본적인 헤더.

iostream은 C++의 입출력을 담당하는 헤더이며 객체지향언어인 C++처럼 iostream에 있는 입출력 함수들 역시 객체로 정의되어 있다. (iostream의 구성 요소 정리)

출처

2. namespace

C++ 표준 라이브러리에 존재하는 모든 변수나 객체는 std 표준 네임 스페이스에 포함된다. 표준 출력 cout 객체를 사용하기 위해서는 std::cout처럼 네임 스페이스를 붙여 사용해야 한다.

네임 스페이스는 정의된 객체나 함수의 소속을 의미한다. a()와 b()에 각각 abc 객체를 선언했을 때 a::abc, b::abc로 접두어만 다르게 해 사용할 수 있다는 뜻

int doSomething(int x, int y)
{
    return x + y;
}

int doSomething(int x, int y)
{
    return x - y;
}

#include <iostream> 
#include "foo.h" 
#include "goo.h" 
int main() 
{ 
    std::cout << doSomething(4, 3);
    return 0; 
}

>> c:\VCProjects\goo.h(4) : error C2084: function 'int __cdecl doSomething(int,int)' already has a body

예제처럼 같은 프로그램에 이 둘을 같이 포함하면 이름과 매개 변수가 같은 함수가 같은 스코프에 있음으로써 이름 충돌이 발생한다.

namespace Foo
{
    int doSomething(int x, int y)
    {
        return x + y;
    }
}

namespace Goo
{
    int doSomething(int x, int y)
    {
        return x - y;
    }
}

이제 Foo안에 doSomething()이, Goo안에 doSomething()이 있다.

각 네임 스페이스 안에 있는 식별자를 찾기 위해서는 스코프 분석 연산자(::)가 필요하다. 이 연산자를 사용하려면 식별자 이름 앞에 사용할 네임 스페이스를 붙이면 된다. Foo::doSomething(x, y), Goo::doSomething(x, y)

#include <iostream> 

int main() 
{ 
    std::cout << Foo::doSomething(4, 3); << '\n'
    std::cout << Goo::doSomething(4, 3); << endl (둘 다 개행 출력임)
    return 0; 
}

참고

Makefile

NAME = megaphone

CPPC = clang++
CPPFLAGS = -Wall -Wextra -Werror
RM = rm -f
MAIN = megaphone.cpp

$(NAME): $(MAIN)
    $(CPPC) $(MAIN) $(CPPFLAGS) -o $(NAME)

all : $(NAME)
clean: $(RM) $(NAME)
re:    clean all

.PHONY: all clean re

⇒ CPPC, CPPFLAGS 매크로명은 여기에서 다른 의미로 쓰이는 것 같아서 다음 과제부터는 이렇게 안 써야지..

megaphone.cpp

#include <iostream>

char    CharUpper(char c)
{
    if ('a' <= c && c <= 'z')
        return (c - ('a' - 'A'));
    return (c);
}

int        main(int argc, char **argv)
{
    int        i;
    int        j;

    std::cout << "0";
    (void) argc;
    if (!argv[1])
        std::cout << "* LOUD AND UNBEARABLE FEEDBACK NOISE *";
    for (i = 1; argv[i]; i++)
    {
        for (j = 0; argv[i][j]; j++)
            std::cout << CharUpper(argv[i][j]);
    }
    std::cout << std::endl;
    return (0);
}

원래 42 norminette 규정으로 for문은 사용하지 못하고 while문으로 반복문을 작성했는데 cpp는 규정이 따로 없어서 for문에 익숙해질겸 작성하였음

C++ Module에서는 C++98만 사용하고 있습니다. 객체 지향 프로그래밍의 기초를 공부하는 것을 목표로 합니다. 현재의 C++와 42에서 공부할 C++가 많은 면에서 다르다는 것을 알고 있다. 숙련된 C++ 코더가 되고 싶다면 현대적인 표준 C++이 필요할 것이다.

General rules

• Header 안에 구현된 모든 기능 및 보호되지 않은 Header는 0 점을 의미합니다
• 모든 출력은 표준 출력이며, 기본적으로 개행으로 끝납니다.
• 파일 이름에는 letter, class name, function name, method name이 와야 합니다.
• 명심하세요. 당신은 이제 C가 아닌 C++로 코딩하고 있습니다.
  • 다음 기능은 금지된 기능입니다. 해당 기능을 사용하면 0 점 처리를 받습니다. *alloc, *printf, free
  • 표준 라이브러리의 모든 것을 사용할 수 있습니다. C++ 버전의 함수를 사용하는 것이 현명할 것입니다.(C++은 새로운 언어이니까요)
  • CPP Module08까지 STL은 사용할 수 없습니다. include를 필요로 하는 vectors, lists, maps 등등
• 명시적으로 금지된 기능이나 기계의 사용은 바로 0 점 처리를 받습니다
• 또한 명시되지 않은 한 C++ 키워드 using namespace및 friend는 금지되어 있습니다.
  • 사용시 -42 점을 받을 것입니다.
• 클래스와 관련된 파일은 별도로 지정되지 않는 한 항상 ClassName.hpp 및 ClassName.cpp입니다.
• 반환 디렉토리는 ex00, ex01, ... , exn입니다.
• 예제를 꼼꼼히 읽어야 합니다. 각 문제의 설명에서는 명확하지 않았던 요구 사항을 포함할 수 있습니다.
• 앞에서 배운 C++도구는 사용할 수 있으므로 외부 라이브러리는 사용할 수 없습니다.
  • C++11과 파생 모델, Boost 또는 C++이 없다면 활용하지 못하는 기술들도 포함입니다 == for문
• 상당한 양의 Class를 제출해야 할 수도 있습니다. 이것을 텍스트 편집기로 스크립팅할 수 없는 경우 지루해 보일 수 있습니다.
• 각 문제를 시작하기 전에 완벽히 이해하셔야 해요!
• 사용할 컴파일러는 clang++입니다.
• 코드는 다음 플래그를 사용하여 컴파일해야합니다: Wall -Wextra -Werror
• 당신의 각 includes는 다른 includes들과 독립적으로 포함될 수 있어야 합니다. Includes는 분명히 그들이 의존하는 다른 모든 include를 포함해야합니다.
• C++에서는 norminette가 적용되지 않습니다. 원하는 스타일대로 작성해 보세요. 하지만 동료 평가자가 읽을 수 없는 코드는 채점 받을 수 없겠죠.
• 중요한 사항 - 서브젝트에 명시되지 않은 한 프로그램에 의해 채점되지 않습니다. 과제를 선택하는 자유가 주어집니다. 하지만 제약에 유의하고 게으름을 피우지 마세요. 연습이 제공하는 많은 것을 놓칠 수 있습니다.
• 제출하는 파일에 일부 관계없는 파일이 있는 것은 문제가 되지 않습니다. 요청한 파일보다 더 많은 파일에 코드를 분리할 수 있습니다. 프로그램에 의해 채점되지 않는 한 자유롭게 하실 수 있습니다.
• 비록 서브젝트의 문제가 짧더라도 알아야 할 것을 확실히 이해하고, 최선의 방법으로 풀었다는 것을 증명하기 위해 시간을 할애할 가치가 있습니다

1. 인터페이스

#인터페이스 #인터페이스구현 #인터페이스란무엇인가? #인터페이스에선언된변수는? #인터페이스와다형성

2. 인터페이스의 여러 요소들

#상수 #디폴트메서드 #디폴트메서드 재정의 하기 #static메서드 #private메서드

인터페이스

동일한 목적 하에 동일한 기능을 수행하게 강제하는 것이 인터페이스의 역할이자 개념 자바의 다형성을 극대화하여 개발 코드 수정을 줄이고 프로그램 유지보수성을 높이기 위해 인터페이스를 사용한다

인터페이스는 interface 키워드를 통해 선언할 수 있으며 implements 키워드를 통해 일반 클래스에서 인터페이스를 구현할 수 있다

public interface 인터페이스명 {
        //상수        
        타입 상수명 = 값; -> 인터페이서에서 값을 지정. 바꾸지 말고 제공한 값만 참고할 것 (절대적)

        //추상 메소드            
        타입 메소드명(매개변수, ... ); -> 가이드만 준다. 추상 메소드를 오버라이팅해서 재구현할 것 (강제적)

        //디폴트 메소드            
        default 타입 메소드명(매개변수, ... ){    -> 인터페이스에서 기본적으로 제공. 수정 가능 (선택적)
          //구현부
        } 

        //정적 메소드            
        static 타입 메소드명(매개변수) {    -> 인터페이스에서 제공해 주는 것으로 무조건 사용해야 함 (절대적)    
          //구현부            
        }
}

절대적 - 변경하면 안 된다 강제적 - 인터페이스를 implements하지 않으면 피할수는 있기에 강제적이라 표현

특징

• class 가 아닌 interace 키워드 사용
  • 파일도 class가 아닌 interface로 생성 가능
  • public과 default 접근제어자 사용 가능
    • 클래스와 비슷한 속성
• 멤버 변수는 항상 public static final 이다
  • 인터페이스에는 클래스 멤버 변수밖에 생성하지 못한다
  • 인터페이스는 객체를 생성하지 않기 때문에 객체 멤버 변수가 없다
    • 객체를 생성하지 않기 때문에 생성자도 없다
  • public static final 키워드는 생략 가능
• 멤버 메소드는 항상 public abstract 이다
  • 정의상으로 모든 메서드가 추상 메소드인 클래스이기 때문에 당연함
  • 오버라이딩을 위한 메서드이기 때문에 private 메소드는 의미가 없다
  • public abstract는 생략 가능하다
• 정적 메소드도 선언 가능하다
  • 정적 메소드는 추상 메소드가 될 수 없다
    • 정적 메소드는 구현부가 있어야 한다
  • 정적 메소드는 오버라이딩할 수 없다
• 인터페이스의 상속은 implements 키워드를 사용한다
• 클래스는 하나만 상속할 수 있으나 인터페이스는 여러 개를 구현 가능
  • extends 하고 하나의 클래스만 적을 수 있지만, 인터페이스는 implements하고 여러 클래스를 적을 수 있다
    • 이때 구현한 인터페이스들의 메소들을 구현 받은 클래스에서 모두 구현해야 함
  • 이를 통해 다중 상속처럼 사용할 수 있다
    • TVCR예제
• 인터페이스명을 자료형으로 하여 구현체의 객체를 참조할 수 있다
  • 상속 관계의 경우와는 다르게 인터페이스의 객체는 생성되지 않는다
  • 그러나 메소드는 오버라이딩하기 때문에 가상 메소드 호출은 일어난다
  • 이를 통해 다형성을 구현할 수 있다
• 추상 메소드가 없다면 구현체에서 메소드 구현을 안 해도 된다
• 인터페이스는 객체를 생성할 수 없다

interface IFoo{
    public static final int MEMBER_VAR = 10; // (상수는 대문자와 '_'조합)
                                            // public static final 생략 가능

    public abstract void methodA(int param); // public abstract 생략가능
    void methodB(int param); // public abstract
}

class Foo implements IFoo{

    @Override
    public void methodA(int param) {
        System.out.println(param);
    }

    @Override
    public void methodB(int param) {
        System.out.println(param);
    }
}

• 인터페이스의 이름 예시
  • 1) interface ifoo < class Foo
    • 상속하는 자식에서 부모쪽으로 화살표한다
  • 2) interface Printable ← class Bar
  • 1)과 같이 인터페이스명에 대문자 I를 붙여서 구분한다
    • 혹은 2)와 같이 형용사로 표현하기 좋은 이름은 그냥 제목으로 표현

썸네일: oneook

1. 추상클래스

#추상메서드(abstract method) #추상클래스(abstract class) #추상클래스를 사용하는 이유? #훅(Hook)메서드 #추상 클래스와 템플릿 메서드 패턴 #final 예약어는 언제 사용하는가?

추상메서드

자식 클래스에서 반드시 오버라이딩 해야 사용할 수 있는 메소드를 의미 선언부만 존재하며 구현부는 작성되지 않는다 → 작성되지 않은 구현부를 자식클래스에서 오버라이딩하여 사용

→ 추상 메소드가 포함된 클래스를 상속받는 자식 클래스가 반드시 추상 메소드를 구현하도록 하기 위함

ex) 모듈처럼 중복되는 부분이나 공통적인 부분은 미리 다 만들어진 것을 사용하고, 이를 받아 사용하는 쪽에서 자신에게 필요한 부분만 재정의해 사용함으로 생상성 향상과 배포 용이

abstract 반환타입 메소드이름();

선언부만 있고 구현부가 없다는 의미로 선언부 끝에 바로 세미콜론(;) 추가

추상클래스

하나 이상의 추상 메소드를 포함하는 클래스를 가리켜 추상 클래스라고 한다 추상 클래스는 객체 지향 프로그래밍에서 중요한 특징인 다형성을 가지는 메소드의 집합을 정의할 수 있도록 함 즉, 반드시 사용되어야 하는 메소드를 추상클래스에 추상메소드로 선언해 놓으면 이 클래스를 상속받는 모든 클래스에서는 이 추상메소드를 반드시 재정의해야 한다

abstract class 클래스이름 {
    ...
    abstract 반환타입 메소드이름();
    ...
}

추상 클래스는 동작이 정의되어 있지 않은 추상 메소드를 포함하고 있으므로, 인스턴스를 생성할 수 없다 추상 클래스는 먼저 상속을 통해 자식 클래스를 만들고, 만든 자식 클래스에서 추상 클래스의 모든 추상 메소드를 오버라이딩하고 나서야 비로소 자식 클래스의 인스턴스를 생성할 수 있다

추상클래스를 사용하는 이유

자식 클래스에서 추상메소드를 반드시 구현하도록 강요하기 위해서 상속받은 자식 클래스에서는 메소드들이 완전히 구현된 것으로 인식하고 오버라이딩하지 않을 수 있기 때문이다 (추상 클래스로 객체를 생성하려면 자식 클래스를 작성해야 하며 추상메소드들을 오버라이딩해야 한다) 이는 추상 클래스를 사용해 유지보수의 편의성을 높이기 위함이고 최소한의 수정으로 원하는 객체를 사용할 수 있게 되어 유지보수성이 좋아진다

템플릿 메서드 패턴

어떤 작업을 처리하는 일부분을 서브 클래스로 캡슐화해 전체 일을 수행하는 구조는 바꾸지 않으면서 특정 단계에서 수행하는 내역을 바꾸는 패턴

• 전체적으로 동일하면서 부분적으로 다른 구문으로 구성된 메서드의 코드 중복을 최소화할 때 유용
• 다른 관점에서 보면 동일한 기능을 상위 클래스에서 정의하면서 확장/변화가 필요한 부분만 서브 클래스에서 구현할 수 있도록 한다
• 예를 들어 전체적인 알고리즘은 상위 클래스에서 구현하면서 다른 부분은 하위 클래스에 구현할 수 있도록 함으로써 전체적인 알고리즘 코드를 재사용하는 데 유용

-장점

코드 중복 감소

자식 클래스의 영할을 감소시키면서 핵심 로직 관리 용이

객체 추가 및 확장 쉽게 가능

-단점

추상메소드가 많아지면 클래스 관리가 복잡

추삭클래스와 구현클래스간 복잡성 증대

구조 설명

AbstractClass

• 템플릿 메서드를 정의하는 클래스
• 하위 클래스에 공통 알고리즘을 정의하고 하위 클래스에서 구현될 기능을 primitive메서드 또는 hook메서드로 정의하는 클래스

ConcreteClass

• 물려받은 primitive메서드 또는 hook메서드를 구현하는 클래스
• 상위 클래스에 구현된 템플릿 메서드의 일반적인 알고리즘에서 하위 클래스에 적합하게 primitive메서드나 hook메서드를 오버라이드하는 클래스

hook메서드

• 선택적으로 오버라이딩할 수 있는 메서드

final 예약어는 언제 사용하는가?

위키백과에서 설명하는 final (Java) 정의와 예제는 다음과 같다.

the final keyword is used in several contexts to define an entity that can only be assigned once.

final 키워드는 엔티티를 한 번만 할당합니다. 즉, 두 번 이상 할당하려 할 때 컴파일 오류가 발생하여 확인이 가능합니다.

썸네일: oneook

앞서 공부한 오버로딩은 서로 다른 시그니처를 갖는 여러 메소드를 하나의 이름으로 정의하는 것

오버라이딩은 상속 관계에 있는 부모 클래스에서 이미 정의된 메소드를 자식 클래스에서 같은 시그니처를 갖는 메소드로 다시 정의하는 것

오버라이딩 조건

1. 메소드의 동작만을 재정의 하기 때문에 메소드의 선언부는 기존 메소드와 완전이 같아야 함 하지만 메소드의 반환 타입은 부모 클래스의 반환 타입이기 떄문에 타입 변환할 수 있는 타입이라면 변경 가능
2. 부모 클래스의 메소드보다 접근 제어자를 더 좁은 범위로 변경할 수 없다
3. 부모 클래스의 메소드보다 더 큰 범위의 예외를 선언할 수 없다

class Parent {
    void display() { System.out.println("부모 클래스의 display() 메소드입니다."); }
}
class Child extends Parent {
    void display() { System.out.println("자식 클래스의 display() 메소드입니다."); }
}

public class Inheritance05 {
    public static void main(String[] args) {
        Parent pa = new Parent();
        pa.display();
        Child ch = new Child();
        ch.display();
        Parent pc = new Child();
        pc.display(); // Child cp = new Parent();
    }
}

>> 실행 결과

부모 클래스의 display() 메소드입니다.
자식 클래스의 display() 메소드입니다.
자식 클래스의 display() 메소드입니다.

// Child cp = new Parent();

예제에서 세 번째와 같은 인스턴스의 참조가 허용되는 이유는 자바에서의 다형성(polymorphism)때문

다형성(polymorphism)

오버로딩과 오버라이딩

오버로딩 - 새로운 메소드 정의 오버라이딩 - 상속받은 기존의 메소드 재정의

밑의 예제는 오버로딩과 오버라이딩 둘 다 수행하는 예제

class Parent {
    void display() { System.out.println("부모 클래스의 display() 메소드입니다."); }
}

class Child extends Parent {
    // 오버라이딩된 display() 메소드
    void display() { System.out.println("자식 클래스의 display() 메소드입니다."); }
    void display(String str) { System.out.println(str); } // 오버로딩된 display() 메소드
}

public class Inheritance06 {
    public static void main(String[] args) {
        Child ch = new Child();
        ch.display();
        ch.display("오버로딩된 display() 메소드입니다.");
    }
}

>> 실행 결과
자식 클래스의 display() 메소드입니다.
오버로딩된 display() 메소드입니다.

형변환

암묵적 형변환

서로 다른 자료형을 연산 혹은 대입하는 경우 자바 컴파일러가 자료형을 통일

→ 표현 범위가 좁은 데이터 타입에서 넓은 데이터 타입으로의 변환만 허용 (데이터 손실이 되기 때문)

명시적 형변환

데이터 손실을 감수하더라도 강제로 형변환 시키는 형태

→ 자료형 b = (변화할 자료형) a; (실수형에서 정수형으로 변환하는 경우 소수점 이하 자리는 버려짐)

public class Main01 {
    public static void main(String[] args) {
        double a = 3.14d;
        int b = (int) a;

        System.out.println(a);
        System.out.println(b);
    }
}

>> 실행 결과
3.14
3

가상 메서드

함수 혹은 메서드는 이름이 그 자체로 주소 역할을 하기 때문에 같은 이름을 가진 다른 메서드가 존재할 수 없지만 오버라이드를 하는 경우 같은 이름의 다른 주소값을 가진 메서드가 재정의 되기 때문에 같은 이름의 다른 기능을 하는 메서드를 가질 수 있다

오버라이드를 할 수 있는 메서드 = 가상 메서

calcPrice는 이름이 같지만 재정의된 다름함수가 존재하고 그 주소값이 다르다. 이럴 때 실제적으로 호출되는 calPrice는 자료형(타입)기준이 아닌 생성된 인스턴스를 기준으로 호출이 되는 것을 가상 메서드 기법이라고 한다

정리해보면 Customer vd = new VIPCustomer(); 일 때 재정의가 안됬을 경우 Customer의 calPrice가 호출되지만 재정의가 됬을 경우 VIPCustoemr의 calPrice가 호출

일반적인 상속의 개념처럼 부모 → 자식 에게 받는 것이 아닌 자식 → 부모를 선택해 상속 받는다.

상속받은 클래스 = 자식 클래스, 하위 클래스, 서브 클래스 라고 부른다 상속해 준 클래스 = 부모 클래스, 상위 클래스, 슈퍼 클래스

상속의 대상

자식 클래스가 상속을 받게 되면 부모 클래스의 필드와 메소드를 받는다. 단, private를 갖는 필드나 메소드는 상속이 불가하고, 패키지가 다른 경우 default인 경우에도 상속이 불가

상속의 방법(선언)

상속받을 자식 클래스 뒤에 extends 키워드를 사용하고 부모 클래스를 적으면 된다

class /*자식 클래스*/ extends /*부모 클래스*/{
    ..
}

자바에서는 자식 클래스가 여러 부모로부터 다중 상속을 받는 것은 불가능하다. 1 개의 부모 클래스로부터 단일 상속만 허용된다. 하지만 여러 개의 자식 클래스에게 상속이 가능

상속의 사용 (예제)

• 예제1

class A {
    String aField = "클래스 A 필드";
    public void aMethod() {
        System.out.println(aField);
    // System.out.println("A : "+ bField); 
        // 컴파일 에러(자식 필드 사용 불가)
    }
}

class B extends A {
    String bField = "클래스 B 필드";
    public void bMethod() {
        System.out.println(aField); // 부모 클래스 필드 사용
        System.out.println(bField); // 본인 클래스 필드 사용
    // System.out.println("B : "+cField); 
    // 컴파일 에러(자식 필드 사용 불가)
    }
}

class C extends B {
    String cField = "클래스 C 필드";
    public void cMethod() {
        System.out.println(aField); // 조부모 클래스 필드 사용
        System.out.println(bField); // 부모 클래스 필드 사용
        System.out.println(cField); // 본인 클래스 필드 사용
    }
}

public class SuperSubEx01 {
    public static void main(String[] args) {
        System.out.println("----------A----------");
        A a = new A();
        a.aMethod(); // 본인 메소드 사용
        // a.bMethod(); // A(부모) 객체로 B(자식) 메소드 접근 불가
        System.out.println("----------A----------");
        System.out.println("----------B----------");
        B b = new B();
        b.aMethod(); // 부모 메소드 사용
        b.bMethod(); // 본인 메소드 사용
        // b.cMethod(); // B(부모) 객체로 C(자식) 메소드 접근 불가
        System.out.println("----------B----------");
        System.out.println("----------C----------");
        C c = new C();
        c.aMethod(); // 조부모 메소드 사용
        c.bMethod(); // 부모 메소드 사용
        c.cMethod(); // 본인 메소드 사용
        System.out.println("----------C----------");
    }
}

A, B, C를 각각 정의하고 A(조부모)→B(부모)→C(자식) 순으로 상속을 받는다. 각 메소드에서 부모 클래스의 필드를 자식 클래스가 사용하여 데이터를 출력한다

main에서 각 클래스 별로 인스턴스를 생성하고 자식 클래스에서 부모 클래스의 메소드를 호출한다

• 예제2

import java.util.Scanner;
class SuperClass {
    int a, b; // 필드
    public void setA(int a) {
        this.a = a; // 필드 a값 설정
    }
    public void setB(int b) {
        this.b = b; // 필드 b값 설정
    }
    public void sum() {
        System.out.println("덧셈 : " + (a + b));
    }
    public void substract() {
        System.out.println("뺄셈 : " + (a - b));
    }
}

class SubClass extends SuperClass {
    public void mul() {
        System.out.println("곱셈 : " + a * b);
    }
    public void div() {
        System.out.println("나눗셈 : " + a / b);
    }
}

public class SuperSubEx02 {
    public static void main(String[] args) {
        System.out.println("2개의 정수 입력");
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        SubClass sub = new SubClass();
        sub.setA(a); // 매개값 전달
        sub.setB(b); // 매개값 전달
        sub.sum();
        sub.substract();
        sub.mul();
        sub.div();
      }
}

자식 클래스에서 부모 클래스의 기능을 물려받고 필요한 기능을 추가한 예제. 자식 클래스가 부모 클래스보다 더 다양한 기능을 수행할 수 있다.

main에서 서브 클래스로 인스턴스를 생성

super와 super()

• protected

  protected는 pubic과 default접근 제한의 중간에 해당한다.

  같은 패키지에서는 default와 같이 접근 제한은 없지만 다른 패키지에서는 자식 클래스만 접근을 허용한다

1. 상속

#[상속] #하위클래스의생성순서 #상위클래스생성자호출 #[super] #[protected]

2. 오버라이딩

#[overriding] #업캐스팅(upcasting) #[묵시적형변환] #상속에서의상위클래스와하위클래스의메모리상태 #가상메서드 #[다형성]

3. 다운캐스팅

#다운캐스팅 #instanceof #명시적형변환

Q. 상속을 언제 사용할 것인가?

Q. 상속이 코드의 재사용을 위한 일반적인 방법이 아니라고 하면 코드를 재사용하기 위한 방법은 무엇이 있을까?

Q. IS-A 와 HAS-A 관계

• A

  IS-A관계(is a relationship : inheritance)

  • IS - A관계는 일반적인(general)개념과 구체적인(specific)개념과의 관계를 뜻합니다. 한 클래스와 다른 클래스가 IS-A관계 일 때 상속을 사용합니다.

  • 상위 클래스는 일반적인 개념 클래스이고(예 포유류) 하위 클래스는 구체적인 개념 클래스(예: 사람, 원숭이, 고래..)에 속합니다.

  • 클래스간에 상속관계가 만들어지면 클래스간에 관계가 타이트해져서 상위 클래스에 변화를 주면 하위클래스에 영향을 주게 됩니다. 그렇기에 단순히 코드를 재사용하는 목적으로 상속을 사용하지는 않습니다.

    HAS-A관계(composition):

  • 반면에 HAS-A관계는 한 클래스가 다른 클래스를 소유한 관계로 코드 재사용의 한 방법입니다.

  • 만약 우리가 ArrayList클래스를 사용하고 싶다면 ArrayList extends하여 사용 하는 것이 아닌 인스턴스를 하나 생성해서 사용하는 것 같이 필요한 코드를 재사용을 위해선 생성해서 사용하면 됩니다.

Q. 하위 클래스가 상위 클래스 형으로 묵시적 형변환이 되는 이유를 메모리로 설명하세요

썸네일: oneook

1. static 변수

#static변수 #static 메서드 #클래스변수 #클래스 메서드 #static 생성 시기

• 학생이 한 명 생성될 때 id가 새로 만들어져야 한다 -> 인스턴스가 공통으로 사용할 변수가 있어야 한다 == static 변수

2. singleton pattern

#singleton pattern #객체의 유일성

• 디자인 패턴에 대해 일찍 공부할 필요는 없지만 알아두면 좋다 'oop코딩'을 조금 해 보면 된다
• 글로벌 변수는 프로그래밍의 악

3. 변수의 종류와 유효성

#지역 변수 #인스턴스 변수 #static 변수의 scope와 life cycle 생성되는 메모리 #언제 소멸되는지

• 코드 영역과 데이터 영역 중 데이터 영역에 어떤 값이 쓰이는지 (상수, 리터럴 등) 같이 공부할 수 있음

4. 객체 배열

#객체배열사용하기 #얕은복사, 깊은복사

• 프리미티브 변수 X
• 배열 복사한 경우에 기존 배열과 복사한 배열의 내용이 같이 변한다

5. ArrayList

#ArrayList 클래스 메서드 #javaDoc #enhanced for문

• jdk에서 제공하는 객체 배열을 위한 클래스

Static

static 변수와 static 메소드는 static 메모리 영역에 존재하기 때문에 객체가 생성되기 이전에 이미 할당되어 있다 -> 객체의 생성 없이 바로 접근할 수 있다

public class MyCalculator {
  public static String appName = "MyCalculator";
    public static int add(int x, int y) {
        return x + y;
    }
    public int min(int x, int y) {
        return x - y;
    }
}

MyCalculator.add(1, 2); // static 메소드 이므로 객체 생성 없이 사용 가능
MyCalculator.min(1, 2); // static 메소드가 아니므로 객체 생성후에 사용가능

MyCalculator cal = new MyCalculator();
cal.add(1, 2); // o 가능은 하지만 권장하지 않는 방법
cal.min(1, 2); // o

Static 변수

• 메모리에 고정적으로 할당되어, 프로그램이 종료될 때 해제되는 변수
• 메모리에 한 번 할당되기 때문에 여러 객체가 해당 메모리를 공유하게 된다

public class Person {
    private String name = "Korea";

    public void printName() {
    System.out.println(this.name);
    }
}

'Korea'에 사는 100 명의 데이터를 수집한다고 했을 때 100명이 사는 지역의 이름을 Korea라고 100 번 저장하지 않고 static을 사용하면 메모리 효율이 더 높아진다

public class Person {
    public static final String name = "Korea";

    public static void  printName() {
    System.out.println(this.name);
    }
}

static 메소드

• static 메소드에서는 static이 선언되지 않은 변수에 접근이 불가능
• static 메소드는 객체의 생성 없이 접근하는 함수이므로 할당되지 않은 메모리 영역에 접근을 하므로 문제가 발생하게 된다 그러므로 static 메소드에서 접근하기 위한 변수는 반드시 static 변수로 선언되어야 한다
• Singleton Pattern 인스턴스가 오직 1 개만 생성되어야 하는 경우에 사용하는 패턴 Singleton Pattern을 구현할 때 멀티 스레딩 환경에서도 동작이 가능해야 하기 때문에 Thread-safe가 보장되어야 한다

Singleton Pattern

인스턴스가 오직 1 개만 생성되어야 하는 경우에 사용하는 패턴 Singleton Pattern을 구현할 때 멀티 스레딩 환경에서도 동작이 가능해야 하기 때문에 Thread-safe가 보장되어야 한다

싱글톤 참고

• Singleton Pattern 방식

  Thread-safe 란? 멀티 스레드 환경에서 동작해도 원래 의도한 형태로 동작하는 코드

  1) Eager Initalzation

  static 키워드의 특징을 이용하여 프로그램이 시작하는 시점에서 정적 바인딩을 통해 해당 공유 인스턴스를 메모리에 올려 사용하는 방식

  2) Lazy initialization

  이른 초기화 방식과 정반대로 클래스가 로드 되는 시점이 아닌 인스턴스가 필요한 시점에 요청할 경우 동적 바인딩을 통해 인스턴스를 생성하는 방식 Thread-safe를 만족 시키기 위해서 synchronized 키워드를 사용한다 사용 전까지 메모리를 차지하지 않는 장점이 있다

  3) Lazy Initialization + Double Checking Locking(DCL, Thread-safe)

  위 방법은 많은 thread 들이 인스턴스를 호출할 경우 성능 저하가 발생하기 때문에 이를 개선한 방법이다.

  이 방식은 인스턴스가 생성되지 않은 경우에만 동기화 블럭이 실행되게끔 구현하는 방식이다

  • 지역 변수, 전역 변수 변수는 "선언위치"에 따라 전역변수와 지역변수로 나눠진다.

  • 전역변수(Global variable) : 어느 위치에서든 호출하면 사용이 가능 (함수 밖에 선언하여 클래스 전체에서 사용이 가능한 변수)

  • 지역변수(Local variable) : 특정구역({ }) 내에서 생성되어 그 구역에서만 사용 (함수 속에 선언되어 해당 함수 속에서만 사용이 가능한 변수)

    public class HelloAndroid {
      //메소드 밖에 있는 변수는 전역변수
      //전역변수의 생명주기는 클래스 끝
    
      static String strr = "전역변수";
    
      public static void main(String[] args) {
          System.out.println(strr);
    
          String local = "지역변수";
          //메소드 안에 넣어준 변수는 지역변수
          //지역변수는 해당하는 메소드만 사용
    
          System.out.println(local);
    
          method1();
      }
      public static void method1() {
          System.out.println(strr);
          //전역변수라 출력 가능
    
          //System.out.println(local);
          //지역변수이기에 출력 불가. 에러발생
      }
    }

    1) 전역 변수

  • 인스턴스 변수 클래스 영역에 선언되어 객체가 생성될 때마다 만들어지고 생성되었을 때만 호출하여 사용할 수 있음

    
    public class ChangeMoney {
          int a;
              //변수 선언
      public static void main(String[] args) {
    
          ChangeMoney ob = new ChangeMoney();
              //이곳에서 사용할 수 있게 선언해준다
    
          System.out.println("int a     :" + ob.a);
                 // 전역 변수는 초기화 하지 않아도 자바가 자동으로 해줌..
      }
    }

  • static 변수 객체를 따로 생성하지 않아도 사용 가능 많으면 실행 속도에 악영향

    public class ChangeMoney {
      static
          int a;
              //변수 선언
      public static void main(String[] args) {
    
          //ChangeMoney ob = new ChangeMoney();
              //static을 해주면 선언 안해줘도 이곳에서 사용할 수 있다
    
          System.out.println("int a     :" + ob.a);
      }
    }

변수의 scope와 life cycle

• 변수의 scope

  scope란? 선언된 변수, 클래스 등의 사용 범위

  

  • Class 안에 var1이란 변수가 선언 됬으면 var1의 스코프는 클래스 전체에서 놀 수 있다. 즉, foo() 메소드 안에서도 들어갈 수 있다
  • 하지만 var2는 어떨까? 저 변수의 스코프는 foo() 안에서의 초록색 칸에서만 사용할 수 있다. 즉, 반대로, var2의 집은 foo() 로 한정되어 있으므로, 집밖으로 나갈 수 없다

• 변수의 life cycle

  Tlife cycle 란? 모든 변수는 생명 주기를 갖는다

  

  • 인스턴스 변수는 객체가 생성될 때, 변수가 생성된다. 즉, 현재 Test 클래스를 static main 메소드나 다른 클래스에서 인스턴스를 생할 때 생성이 된다. 그리고 인스턴스는 참조가 없을 때 가비지 컬렉터가 객체를 지워버리게 되는데 이때, 인스턴스 변수도 같이 소멸된다.
  • 매개변수는 예를들어 저 코드의 foo() 의 메소드가 호출 될 때 var3가 생성되고 foo() 의 메소드가 종료 시점에 var3로 소멸 된다.
  • 지역변수 Local 변수는 ‘ { ‘ 가 시작되는 시점에 생성되며, ‘ } ‘ 로 끝나는 시점에 소멸된다.
  • 정적변수는 클래스가 처음 호출 되면서 생성이 되고, 자바 어플리케이션이 종료되는 시점에 같이 소멸된다

얕은 복사, 깊은 복사

얕은 복사 - 주소 값을 복사한다 (참조하는 실제 값은 같다) 깊은 복사 - 실제값을 새로운 메모리 공간에 복사한다 (실제값이 다르다)

• ArrayList 클래스 Collection 프레임워크의 List인터페이스의 제너릭 클래스를 배열 형태로 관리할 수 있도록 하는 클래스로 순차적으로 자료를 저장하여 관리하는 프로그램을 구현할 때 사용되는 클래스
• JavaDoc java 소스에 문서화를 하는 방법으로 클래스나 메소드에 주석으로 기술한 내용을 javadoc 명령어나 이를 이용한 빌드 툴을 사용하여 문서화할 수 있다
• Enhanced For Loop (향상된 for문)

1. 기존 For Loop

for(초기값 ; 조건식 ; 증감식) { // } 2. 향상된 Enhanced For Loop

for(초기화 : 배열) { // }

Enhanced For Loop 장단점

장점 :

1. 배열의 크기를 조사할 필요가 없다.
2. 반복문 본연의 반복문 구현에 집중하여 구현할 수 있다.

단점 :

1. 배열에서만 사용가능하고, 배열의 값을 변경하지 못한다.

썸네일: oneook

1. 윤년 계산기 만들기

#private #information hiding #encapsulation #접근제어자 #getter/setter

2. this 예제 만들기

#this #생성자에서 this 사용할 때 주의 할 점

3. 참조 자료형 변수

#클래스 분리

4. 개체 협력

#객체 단일성

뒤늦게 노션에 정리하기 시작해서 미처 다 기록을 하지 못했다 ㅠㅜ

썸네일: oneook