#include<iostream>

using namespace::std;

template<typename T>

class Stack

{

T arr[5];

int index;

int front;

public:

Stack() : index(0)  {};

void Push(T num) 

{

arr[index++] = num;

}

void Pop()

{

cout << arr[--index] << endl;

}

void Empty()

{

}

};

int main()

{

Stack<int> st;

st.Push(10);

st.Push(20);

st.Push(30);

st.Pop();

st.Pop();

st.Pop();

}

#include <iostream>

#include <cstring>

using namespace std;

const int NAME_LEN = 20;

enum { MAKE = 1, DEPOSIT, WITHDRAW, INQUIRE, EXIT };

class Account

{

int id;      // 계좌번호

int balance;    // 잔    액

char *name;   // 고객이름

public:

Account(int id, char *name, int balance);

Account(const  Account& _Account);

~Account();

int getID() const; //계좌조회

virtual void AddMoney(int money); //입금

void MinMoney(int money); //출금

int getBalance() const; //잔액조회

char* getName() const; //이름

virtual void ShowAllData();

};

Account::Account(int id, char *name, int balance) {

this->id = id;

this->name = new char[strlen(name) + 1];

strcpy(this->name, name);

this->balance = balance;

}

Account::Account(const  Account& _Account)

{

this->id = _Account.id;

this->name = new char[strlen(_Account.name) + 1];

strcpy(this->name, _Account.name);

this->balance = _Account.balance;

}

Account::~Account()

{

delete name;

}

int Account::getID() const

{

return id;

}

void Account:: AddMoney(int money)

{

this->balance += money;

}

int Account:: getBalance() const

{

return balance;

}

void Account:: MinMoney(int money)

{

balance -= money;

}

char* Account:: getName() const

{

return name;

}

void Account::ShowAllData()

{

cout << "ID : " << id << endl;

cout << "이름 : " <<name << endl;

cout << "잔액 : " << balance << endl;

}

//신용계좌 입금시 1프로 추가

class FaithAccount : public Account

{

public:

FaithAccount(int id, char *name, int balance) : Account(id, name, balance + balance * 0.01)

{

}

void AddMoney(int money)

{

Account::AddMoney(money + money * 0.01);

}

};

//기부계좌 입금액 1프로 기부 기부총액 저장

class ContriAccount : public Account

{

int contri_sum; //기부금 합

public:

ContriAccount(int id, char *name, int balance) : Account(id, name, balance - balance * 0.01)

{

contri_sum += balance * 0.01;

}

void AddMoney(int money)

{

Account::AddMoney(money - money * 0.01);

contri_sum += money * 0.01;

}

void ShowAllData()

{

Account::ShowAllData();

cout << "총기부액 : " << contri_sum << endl;

}

};

class AccManger

{

Account* pArr[100];   // Account 저장을 위한 배열

int index;        // 저장된 Account 수

public:

AccManger() :index(0)

{};

void ShowMenu(void);       // 메뉴출력

void MakeAccount(void);    // 계좌개설을 위한 함수

void DepositMoney(void);       // 입    금

void WithdrawMoney(void);      // 출    금

void Inquire(void);     // 잔액조회

};

int main(void)

{

int choice;

AccManger ac;

while (1)

{

ac.ShowMenu();

cout << "선택: ";

cin >> choice;

cout << endl;

switch (choice)

{

case MAKE:

ac.MakeAccount();

break;

case DEPOSIT:

ac.DepositMoney();

break;

case WITHDRAW:

ac.WithdrawMoney();

break;

case INQUIRE:

ac.Inquire();

break;

case EXIT:

return 0;

default:

cout << "Illegal selection.." << endl;

}

}

return 0;

}

void AccManger::ShowMenu(void)

{

cout << "-----Menu------" << endl;

cout << "1. 계좌개설" << endl;

cout << "2. 입    금" << endl;

cout << "3. 출    금" << endl;

cout << "4. 계좌정보 전체 출력" << endl;

cout << "5. 프로그램 종료" << endl;

}

void AccManger::MakeAccount(void)

{

int id;

char name[NAME_LEN];

int balance;

int sel;

cout << "1. 일반계좌 개설" << endl;

cout << "2. 신용계좌 개설" << endl;

cout << "3. 기부계좌 개설" << endl;

cout << ">>";

cin >> sel;

cout << "[계좌개설]" << endl;

cout << "계좌ID: "; cin >> id;

cout << "이  름: "; cin >> name;

cout << "입금액: "; cin >> balance;

cout << endl;

if (sel == 1)

pArr[index++] = new Account(id, name, balance);

else if (sel == 2)

pArr[index++] = new FaithAccount(id, name, balance);

else if (sel == 3)

pArr[index++] = new ContriAccount(id, name, balance);

else

cout << "오류"<<endl;

}

void AccManger::DepositMoney(void)

{

int money;

int id;

cout << "[입    금]" << endl;

cout << "계좌ID: "; cin >> id;

cout << "입금액: "; cin >> money;

for (int i = 0; i<index; i++)

{

if (pArr[i]->getID() == id)

{

pArr[i]->AddMoney(money);

cout << "입금완료" << endl << endl;

return;

}

}

cout << "유효하지 않은 ID 입니다." << endl << endl;

}

void AccManger::WithdrawMoney(void)

{

int money;

int id;

cout << "[출    금]" << endl;

cout << "계좌ID: "; cin >> id;

cout << "출금액: "; cin >> money;

for (int i = 0; i<index; i++)

{

if (pArr[i]->getID() == id)

{

if (pArr[i]->getBalance()<money)

{

cout << "잔액부족" << endl << endl;

return;

}

pArr[i]->MinMoney(money);

cout << "출금완료" << endl << endl;

return;

}

}

cout << "유효하지 않은 ID 입니다." << endl << endl;

}

void AccManger::Inquire(void)

{

for (int i = 0; i<index; i++)

{

pArr[i]->ShowAllData();

}

}

//은닉 특성

#include<iostream>

using namespace std;

class A

{

public:

void fct()

{

cout << "A"<<endl;

}

};

class B : public A

{

public:

void fct()

{

cout << "B" << endl;

}

};

int main()

{

B* b1 = new B;

b1->fct();

A* a1 = b1;

a1->fct();

}

//virtual 넣어서 재정의 특성

#include<iostream>

using namespace std;

class A

{

public:

virtual void fct()

{

cout << "A"<<endl;

}

};

class B : public A

{

public:

void fct()

{

cout << "B" << endl;

}

};

int main()

{

B* b1 = new B;

b1->fct();

A* a1 = b1;

a1->fct();

}

오류 되는 문장 p2->Work();

이유 : 

person <-student<-partimestd  상속 관계

partimestd 주소를 student 포인터로 저장이 가능하지만

접근 권한이 student 기준이라 partimestd 객체 함수 접근 권한이 없음

반대로 partimestd 포인터로  student 주소를 저장 할 수 없다.

partimestd는 partimestd이지만

student는 상속으로 student는partimestd이다 성립

간단히 말해서 객제포인터로 저장하려면 상속을 받는 하위 클래스이어야한다.

class A

{...소스소스

}

 A(10)

java , c# 생성과 동시에 초기화 가능

A(10)

A

c++안됨 이렇게 밖에 생성안되면 void생성자가 있어야하는데?

그래서 c++은 무조건 void 생성자가 디폴트로 들어간다

A(){...}

class A

{

int x,y;

A(int _x=0,int _y=0) : x(_x),y(_y)

}

_x=0 _y=0  디폴트 변수고

x(_x),y(_y) 객채가 생성되고 생성자가 호출됬을떄 사용되는 초기화 리스트다 

x<-_x

y<-_y  초기화

햇갈려 하는 사람이 많아서 대충 적어둠

Foo(int num): bar(num) 은 초기화 리스트라고 하고, 멤버 변수 bar를 num으로 초기화하는 역할을 합니다.

//초기화 리스트
Foo(int num): bar(num) {};

//함수에서 초기화
Foo(int num)
{
   bar = num;
}

그냥 생성자 함수{} 내에서 초기화하는 것과, 이렇게 초기화 리스트를 쓰 는것의 차이는

초기화 리스트에서 초기화를 하는 경우, 생성자가 호출될 때 객체의 생성과 초기화가 한 번에 이루어집니다.

생성자 함수 내{}에서 초기화를 하는 경우, 객체가 생성되어, default생성자로 초기화된 상태에서 다시 한 번 할당받게 하게 됩니다. 이 경우엔 default할당-유저할당의 2단계를 거치게 돼서 오버헤드가 생깁니다.

초기화 리스트를 써야만 하는 상황은 크게 다음과 같습니다

• 클래스가 레퍼런스를 멤버로 가질 때
• non static const멤버가 있을 때
• default 생성자가 없을 때
• base class를 초기화할 때
• 생성자 파라미터의 이름이 데이터 멤버랑 같을 때(이 경우는 this를 써서 해결할 수도 있습니다)

예를 들면

class MyClass
{
    public:
        int &i; //레퍼런스 멤버. 초기화 리스트를 써야 함
        int b;
        //Non static const 멤버. 초기화 리스트를 써야 함
        const int k;  

    //생성자 파라미터의 이름이 데이터 멤버랑 같음. 초기화 리스트를 쓸수 있음(선택 가능)
    MyClass(int a, int b, int c):i(a),b(b),k(c)
    {
        /*
        초기화 리스트를 쓰고 싶지 않은 경우
        this->a = a
        같이 써야 함
        */
    }
};

class MyClass2:public MyClass
{
    public:
        int p;
        int q;
        //base class인 MyClass가 default생성자가 없기 때문에 무조건 초기화 리스트에서 초기화해줘야 함
        MyClass2(int x,int y,int z,int l,int m):MyClass(x,y,z),p(l),q(m)
        {
        }

};

int main()
{
    int x = 10;
    int y = 20;
    int z = 30;
    MyClass obj(x,y,z);

    int l = 40;
    int m = 50;
    MyClass2 obj2(x,y,z,l,m);

    return 0;
}

출처 :  http://hyem2.tistory.com/

C/C++ 기본 구문

- const 위치에 따른 구문의 의미

- by Tapitolife

지식iN에 이런 질문이 올라 왔더군요.

원문 출처: http://kin.naver.com/qna/detail.nhn?d1id=1&dirId=1040101&docId=124932419

본디 상수 특성을 지정하는 const키워드는 그 놓인 위치에 따라 약간의 미묘한 의미 차이를
갖는데요…… 물론 이 질문에 제가 답변을 올렸고 채택이 되었습니다. ㅎㅎ
그러고 보니 저도 가끔 이 const 키워드가 들어갔을 때 그 의미를 혼동하는 경우가 있는데요.
이번 지식iN 답변을 계기로 저도 한번 제대로 const 키워드가 들어간 구문의 정확한 의미를
정리해 보렵니다.

const는 여러 곳에 놓일 수 있습니다. 그 때문에 의미가 혼동되기도 쉽죠.

변수 선언 시: [const] 자료형 [const] [포인터] [const] 변수명;
함수 선언 시: [const] 자료형 [const] [포인터] 함수명(매개변수…) [const] { }

뭐… 이렇게만 놓고 보면 무슨 말인지 감이 안 잡히니까,
예를 들어가면서 이야기 해 보기로 하죠. const는 어느 곳에 붙든 결국 원칙은 이겁니다.

"const가 붙으면 값 변경이 안 된다."

그렇다면 값 변경이 안 되는 경우(어디서 값 변경이 안 되는가?)를 찾는 것이 관건입니다.
질문 원문에서 소개 된 3가지 경우를 예로 들어 보죠.
1번. const int ** a,
2번. int * const * a,
3번. int ** const a

이 3가지의 자료형이 있습니다.
const가 붙는 위치가 조금씩 다른데요, 여러분은 이 차이를 명확히 구분하실 수 있습니까?
(만일 그렇다면 진정한 C언어 고수이십니다. ㅎㅎ)

위의 3가지 형식을 괄호로 쳐 본다면 다음과 같이 묶을 수 있습니다.
1번. (const int) ** a,
2번. (int * const) * a,
3번. (int **) const a

1번은 const int 형에 대한 이중 포인터입니다. 즉 int형 상수에 대한 이중 포인터이죠.
쉽게 나타낸다면 이런 과정으로 만들어지는 타입입니다.
const int x = 10;

const int * y = &x; // &x의 자료형이 const int** 형이라 보면 됩니다.
여기서 알맹이 값인 a = 10이라는 값이 상수처리 되는 거죠.

달리 말하면,
a = const int ** 형 (값 변경 O)
*a = const int * 형 (값 변경 O)
**a = const int 형 (값 변경 X)

2번은 int * 형이 갖는 주소 값을 상수로 정했습니다.
즉 이런 과정을 통해 만들어지는 형식인 거죠.
int x = 10;
int * const y = &x; // &x의 자료형이 int * const * 형이라 보면 됩니다.
여기서 알맹이 값인 a = 10은 그냥 막 수정 가능하고, a의 주소를 갖고 있는 b가 상수인 거죠.

달리 말하면,
a = int * const * 형 (값 변경 O)
*a = int * const 형 (값 변경 X)
**a = int 형 (값 변경 O)

3번은 int ** 형 자체가 상수형으로 지정되었습니다.
즉 이런 과정을 통해 만들어지는 형식인 거죠
int x = 10;
int * y = &x;
int ** const z = &y;

달리 말하면
a = int ** const 형 (값 변경 X)
*a = int * 형 (값 변경 O)
**a = int 형 (값 변경 O)

지식 iN에도 설명을 올렸지만 여기서 다시 한번 표로 정리를 해 보면 아래와 같습니다.

const와 애스터리스크가 연달아 나오는 경우라면, 뒤에서부터 애스터리스크를
지워 나가는 방식을 추천해드리고 싶네요. 지워 나가다가 const가 걸리는 곳이
상수 취급 되는 곳이니까요.

strcpy 같은 함수를 보면 두 번째 인수가 const char * 형으로 되어 있을 겁니다.
풀이해 보면, 그 문자열의 주소는 경우에 따라 가변적이지만
문자열이 갖는 자체의 내용만큼은 변함이 없다. 이런 뜻입니다.

그럼 한번 테스트 해 볼까요?
아래 나온 코드들 간단한 거니까 직접 실습 해 보세요.

소스 A1

소스 A2

소스 B1

소스 B2

소스 A1는 컴파일부터 실행까지 잘 되지만, 소스 A2는 컴파일 오류가 납니다.
A2에서는 str의 주소 자체가 상수이기 때문에 이후 변경될 수 없어서 생기는 오류입니다.
B1과 B2도 같은 맥락입니다.

그럼 이제 다 되었는가? 아닙니다. 하나 더 있습니다.
지금까지는 변수 선언을 할 때만 const가 붙었지만, C++에서 멤버 함수를 선언할 때
아예 함수에다가 const를 붙일 수도 있습니다.

이 때 함수에 붙이는 const의 의미는 무엇이냐 하면…

이 함수는 멤버 변수가 갖는 값을 가져다 쓸 수는 있어도 변경은 할 수 없다.

이런 의미를 갖습니다.

이런 예제를 보여드리면 될까요?

출처: http://tapito.tistory.com/31

#include<iostream>

using namespace std;

class Calculator

{

private:

float sum;

int add_num;

int min_num;

int div_num;

int mul_num;

public:

void Init()

{

sum=0;

add_num=0;

min_num=0;

div_num=0;

mul_num=0;

}

float Add(float s1,float s2)

{

add_num++;

sum=s1+s2;

return sum;

}

float Min(float s1,float s2)

{

min_num++;

sum=s1-s2;

return sum;

}

float Div(float s1,float s2)

{

div_num++;

sum=s1/s2;

return sum;

}

float mul(float s1,float s2)

{

mul_num++;

sum=s1*s2;

return sum;

}

void ShowOpCount()

{

cout<<"덧셈 :"<<add_num<<" 뺼셈 : "<<min_num<<" 나눗셈 : "<<div_num<<" 곱셈 : "<<mul_num<<endl;

}

};

int main(void)

{

Calculator cal;

cal.Init();

cout<<"3+5="<<cal.Add(3,5)<<endl;

cout<<"3/5="<<cal.Div(3,5)<<endl;

cout<<"12*4="<<cal.Min(12,4)<<endl;

cout<<"12/4="<<cal.Div(12,4)<<endl;

cal.ShowOpCount();

return 0;

}

#include<iostream>

#include<string>

using namespace std;

class Printer{

private:

char str[100];

public:

void SetString(char *string);

void ShowString();

};

void Printer::SetString(char *string)

{

strcpy(str,string);

}

void Printer::ShowString()

{

cout<<str<<endl;

}

int main()

{

Printer pnt;

pnt.SetString("Hello world!");

     pnt.ShowString();

     pnt.SetString("I love C++");

     pnt.ShowString();

     return 0;

return 0;

}