$$config title: C++(자료들) keywords: - IT - ... $$ # 수업 페이지 주소 - [https://to2.kr/dQe](https://to2.kr/dQe) - [만족도 조사](http://st.koreaedugroup.com/2019/login.asp) # 세팅 - [visual studio](https://visualstudio.microsoft.com/ko/) ``` - 설치 항목에서 c++를 사용한 데스크톱 개발 선택한후 우측 하단에 설치 버튼 클릭하여 설치. - 설치 완료 후 실행. 로그인 화면 나오면 나중에 로그인 선택. - 새프로젝트 만들기 - 프로젝트 폴더 이니셜로 자신의 폴더 생성(예시 : c:/ctj/work) - 소스 파일 폴더 우클릭 - 추가 - 새 항목 - 파일이름 main.cpp로 작성 - 옵션 설정 - 도구 - 옵션 - 환경 - 글꼴 및 색 - 글꼴: Consolas, 글자크기 : 16 - 도구 - 옵션 - 텍스트 편집기 - C/C++ - 고급 - IntelliSense 사용 안 함 True ``` # 유용한 링크 - [프로그래머스](https://school.programmers.co.kr/learn/challenges) # 2022.07.09 ## 출력 - c에서는 입출력을 하기 위해서는 stdio.h를 인클루드 해 printf()나 scanf()를 사용해서 입출력을 했습니다. - c++에서는 입출력을 하기위해 \ (input output stream)을 인클루드 해야 합니다. - c와 동일하게 메인 메서드를 넣어줘야 합니다. - printf는 cout(console output)으로, scanf는 cin(console input)으로 바뀌게 됩니다. - 그런데 그냥 사용하는 것이 아니라 앞에 std::를 붙여줘야합니다. - std는 네임스페이스(namespace)라고 하는 이름을 담는 공간으로 보시면 됩니다. - 즉, std라는 공간에 cout가 들어있다고 보면 됩니다. ```c std::cout << " "; ``` - << 오른쪽에 출력하고자 하는 내용을 넣으면 됩니다. - 만약에 여러개 출력하고자 할 때는 연산자를 사이에 두고 출력하고자 하는 내용을 여러개 적으면 됩니다. - 예제 ```c #include int main() { std::cout << "hello, world"; std::cout << "hello, world" << std::endl; std::cout << "hello, world" << " " << "c++"; } ``` - std::endl을 사용하면 줄바꿈을 할 수 있습니다. - std:: 을 출력하거나 줄바꿈을 할 때 마다 반복해줘야 합니다. - 상단에 using namespace std; 라고 적으면 더 이상 붙이지 않아도 됩니다. - cout의 장점은 자료형에 상관없이 출력을 해준다는 것 입니다. ``` int a = 10; double b = 9.8; char c = 'A'; cout << a << " " << b << " " << c; ``` ## 입력 - 입력은 cin을 사용합니다. - cout과 비슷하나 연산자의 방향이 반대 입니다. >> - 또한 scanf()를 사용할 때와 같이 주소값을 넘겨주지 않고, 변수명을 그대로 넣어주면 됩니다. ``` #include using namespace std; int main() { int d; cout << "숫자를 입력해 주세요 >> " << endl; cin >> d; cout << "입력하신 숫자는 " << d << "입니다." << endl; } ``` ### 문제 > 두 수를 입력받아 더하는 프로그램을 만들어 주세요, 두개의 숫자를 입력해 주세요 >> 2 5 2 + 5 = 7 ``` #include using namespace std; int main() { int a, b; cout << "두개의 숫자를 입력해 주세요 >> "; cin >> a >> b; cout << a << " + " << b << " = " << a + b; } ``` ## string - string은 c++에 있는 문자열 자료형입니다. - 이를 사용하기 위해서는 string을 인클루드 해야합니다. ``` #include int main(){ string a = "hello, world"; } ``` - 위와 같이 자료형 자리에 string을 넣어 사용하면 됩니다. - 배열에서와 마찬가지로 인덱싱할 수 있습니다. ``` string a; cout << "문자열을 입력해 주세요"; cin >> a; cout << a[0] << a[1]; ``` ## 변수 초기화 - 변수의 초기화는 변수를 선언함과 동시에 값을 할당하는 것을 말합니다. - c++에서는 초기화하는 다른 방법이 있습니다. - 식 ``` 자료형 변수이름(값); ``` - 위와 같이 사용하면 초기화 됩니다. ``` int a = 10; int a(10); ``` - 위의 두 방법 모두 c++에서 사용 가능합니다. ## 레퍼런스 변수 - 레퍼런스 변수는 간단하게 말하면 별명을 붙이는 것을 말합니다. ``` // 레퍼런스 // 별명을 붙인다. /* int a; int* b = &a; int& ref = a; // 레퍼런스 변수는 초기화해서 사용해야한다. // 다음은 불가능 하다 // int& refA = a + 1; // int& refB; ref = 5; cout << ref << " " << a << endl; int x, y; cin >> x >> y; swap(x, y); cout << "x : " << x << ", " << "y : " << y; */ int a(10); int& b = a; // 메모리 상에 저장된 공간이 있는 값만 가리켜야 한다. // 레퍼런스 변수가 가리킬 수 없는 값 // 상수, 함수의 리턴 값, 식 /* int& c = test(); int& d = 100; int& e = a + 5; */ // 레퍼런스 변수의 장점 // 원본 변수를 다른 함수에서 직접 수정할 수 있다. // 불필요한 복사를 줄일 수 있다. ``` - 비교해보기 ||값에 의한 호출|주소에 의한 호출|참조에 의한 호출| |------|---|---|---| |복사되는 값|원본 변수의 값|원본 변수의 주소값|복사 없음| |인수|원본 변수의 값|원본 변수의 주소값|원본 변수의 변수명| |매개변수|int|int*|int&| |언어|c, c++|c, c++| c++| ## l-value, r-value ``` #include using namespace std; void swap(int &a, int &b) { int temp = a; a = b; b = temp; } int testA() { return 100; } int main() { // r-value , l-value // l-value = r-value // l-value는 메모리 어딘가에 저장되어있다. // 새로운 값을 대입할 수 있다. // 변수, 배열, 구조체 int b; b = 100; int c[5]; c[0] = 1; struct{ int x; } d; d.x = 10; // r-value // 메모리상에 존재하지 않으며 등호의 좌면에 올 수 없는 것 // 상수, 식, 함수의 반환 값, 주소값 /* 10 = 15; int e = 5; e + 1 = 10; int f[10]; &f = &e; // &f == &f[0] f = e; test() = 10; */ // 레퍼런스 변수는 l-value만 가리킬 수 있다. // r-value를 가리키고자 한다면 && 사용하면 된다. int test = 10; int&& ref = test + 1; int&& refA = testA(); } ``` ## for문 - 식 ``` for (변수(원소) : 반복 가능한 객체) { 반복 내용 } ``` ``` #include using namespace std; int main() { // for /* for (초기조건; 반복조건; 증가 / 감소) { 반복내용 } */ /* for (변수(원소) : 반복 가능한 객체) { 반복 내용 } */ int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; // 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 for (int i = 0; i < 10; i++) { cout << arr[i] << " "; } cout << endl; for (int &k : arr) { k++; cout << k << " "; } cout << endl; for (int j : arr) { cout << j << " "; } // j는 배열의 원소에 해당 } ``` ## 함수 ### 오버로드 ```cpp #include using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } void swap(double& a, double& b) { double temp = a; a = b; b = temp; } void swap(char& a, char& b, char&c) { char temp = a; a = b; b = temp; } int main() { int a = 1, b = 3; swap(a, b); cout << a << " " << b << endl; double c = 1.2, d = 5.6; swap(c, d); cout << c << " " << d << endl; char e = 'a', f = 'b', g='c'; swap(e, f, g); cout << e << " " << f << " " << g < using namespace std; void swap(int &a, int &b){ int temp = a; a = b; b = temp; } void swap(double& a, double& b) { double temp = a; a = b; b = temp; } void swap(char& a, char& b, char&c) { char temp = a; a = b; b = temp; } int main() { int a = 1, b = 3; swap(a, b); cout << a << " " << b << endl; double c = 1.2, d = 5.6; swap(c, d); cout << c << " " << d << endl; char e = 'a', f = 'b', g='c'; swap(e, f, g); cout << e << " " << f << " " << g < 이름과 나이를 입력해 출력하는 프로그램을 만들어 주세요 >이름입력 : 윤혜림 >나이입력 : 30 >윤혜림님의 나이는 30입니다. ```cpp int main() { string name; cout << "이름입력 : "; cin >> name; int age; cout << "나이입력 : "; cin >> age; cout << name << "님의 나이는 " << age << "입니다."; return 0; } ``` ## 2. for문 > 이차원 배열을 하나 만들어서 안에 있는 값을 출력하는 프로그램을 만들어 주세요 >int arr = {{1,2,3}, {4,5,6}}; > 중첩 for문 > 이전에 알고있던 for와 어제 한 for를 함께 사용 ```c++ int arr[2][3] = { {1,2,3}, {4,5,6} }; for (int i = 0; i < 2; i++) { for (int j : arr[i]) { cout << j << " "; } cout << endl; } ``` ## 3. 오버로딩 > 인벤토리에 무기가 5개 들어있습니다. > 각각의 무기는 인덱스로 번호를 가집니다. >[0, 1, 5, 100, 0] > 점수 변수를 만들어 주세요. > 한개 가질 수도 있고 getItem(1) > 한 아이템을 여러개 가질 수도 있고 getItem(2, 5) > 한 아이템을 여러개 가지고 점수도 얻을 수 있다. getItem(3, 10, 100) > for(:)를 돌려서 인벤토리를 출력합니다. > score도 출력합니다. ``` int inventory[5] = { 0 }; int score = 0; void getItem(int item) { inventory[item]++; //1 } void getItem(int item, int count) { inventory[item] += count; // 내가 가진 개수 만큼 들어가게 된다. } // 내가 가진 개수만큼 들어가고 점수도 얻는다. void getItem(int item, int count, int point) { inventory[item] += count; score += point; } int main() { getItem(1); getItem(3, 5); getItem(0, 10, 100); for (int i : inventory) { cout << i << " "; } cout << endl; cout << "score : " << score; } ``` ## 디폴트 매개변수 ``` #include #include using namespace std; void test(int a = 10) { cout << a << endl; } void test2(int a, int b, int c = 5) { cout << a << " " << b << " " << c << endl; } // 디폴트 매개변수는 뒤에서부터 차례대로 지정해주어야 한다. // 인수가 어디에 들어가야 하는지 모호해지기 때문이다. // void test2(int a, int b, int c = 5) -> OK // void test2(int a = 8, int b, int c = 5) -> No int main() { // 디폴트 매개변수 test(100); test(); test2(1, 2); test2(1, 100, 10000); } ``` ## 네임스페이스 - 네임스페이스 만들기 ``` namespace 이름 { 변수나 함수 } ``` - 예제 ``` #include #include using namespace std; int a; void test() { a = 5; } namespace student { int name; void namePrint() { name = 10; // student::name 이라고 사용해야 맞지만 같은 네임스페이스 안에 있다면 생략 가능 } } namespace book { int name; void namePrint() { name = 100; // 같은 네임스페이스안에 있는 name변수에 값을 대입 student::name = 100; // student네임스페이스 안에 있는 name변수에 값을 대입 } } int main() { // namespace // std // 학생이름 name // 책이름 name // 네임스페이스 밖에서(전역네임스페이스 혹은 main) // 네임스페이스 안에있는 변수나 함수를 사용하고자 하면 // 네임스페이스 이름을 반드시 명시해야한다. student::namePrint(); cout << student::name << endl; book::namePrint(); cout << book::name << endl; cout << student::name << endl; } ``` ## 네임스페이스에서 함수정의 - 네임스페이스 안에서 선언된 함수는 네임스페이스 밖에서 정의할 수 있다. ``` #include #include using namespace std; namespace num { int x, y; void sum(int a, int b); } int main(){ } void num::sum(int a, int b) { cout << a + b; } ``` ## 중첩 네임스페이스 ``` #include #include using namespace std; namespace num { int x, y; void sum(int a, int b); /* void sum(int a, int b){ cout << a + b; } */ } namespace test { void a(int &a, int &b); int a; namespace aaa { int a; void funA(); } } namespace abc { int a, b; void ab(); // 선언 namespace ccc { int a; int c; void cc(); } } void abc::ab() { a = 100; } void abc::ccc::cc() { a = 10000; b = 50; c = 10; abc::a = 5000; } void test::a(int &a, int &b) { cout << a + b << endl; } void test::aaa::funA() { cout << "중첩네임스페이스" << endl; } int main() { // 네임스페이스에서 함수정의 // 중첩 네임스페이스 /* int x, y; cout << "더하고자 하는 숫자를 입력해 주세요. >> "; cin >> x >> y; test::a(x, y); test::aaa::funA(); */ abc::ab(); abc::ccc::cc(); cout << abc::a << endl; cout << abc::b << endl; cout << abc::ccc::c << endl; cout << abc::ccc::a << endl; } void num::sum(int a, int b) { cout << a + b; } ``` ## using - using을 사용하면 네임스페이스의 이름을 생략 할 수 있습니다. - 다만 네임스페이스 안에는 같은 이름의 변수 혹은 함수가 있을 수 있기 때문에 using을 사용할 때 조심해야합니다. ``` using namespace 네임스페이스 이름; ``` # 2022.07.16 ## 문자열 메소드 - 문자를 출력 - 인덱스 - at() - front() - back() - 문자열 용량 - empty() - capacity() - length() - 나머지 메소드 - clear() - substr() - replace() - compare() - swap() - find() - push_back() - pop_back() ``` #include #include using namespace std; int main() { string stringA = "hello"; // 출력 cout << stringA[0] << endl; cout << stringA.at(0) << endl; cout << stringA.front() << endl; cout << stringA.back() << endl; // 문자열 용량 cout << stringA.empty() << endl; cout << stringA.capacity() << endl; cout << stringA.length() << endl; cout << stringA << endl; //stringA.clear(); //cout << stringA << endl; // substr(index, length) -> index부터 length만큼 잘라서 반환 cout << stringA.substr(2, 3) << endl; // replace(index, length, string) -> index부터 length만큼 string으로 변환 cout << stringA.replace(2, 2, "aa") << endl; string s1 = "aaa"; string s2 = "abc"; string s3 = "aq"; string s4 = "aaa"; // 빠르면 -1, 같으면 0, 느리면 1 cout << s1.compare(s2) << endl; cout << s1.compare(s4) << endl; cout << s2.compare(s1) << endl; string a = "hello"; string b = "bye"; string o = "o"; swap(a, b); cout << "a : " << a << endl; cout << "b : " << b << endl; // 인덱스 cout << b.find(o) << endl; cout << a.find(o) << endl; a.push_back('A'); cout << a << endl; a.pop_back(); cout << a << endl; } ``` ## 클래스와 객체 ### C언어 구조체 - 클래스와 객체가 이전에 c에서의 구조체와 비슷합니다. - 먼저 c에서 구조체를 어떻게 만들었는지 복습 하면 다음과 같습니다. - 구조체 만들기 ``` struct 구조체 이름 { 자료형 멤버; }; ``` - 예제 ``` struct number { int a; int b; }c; int main() { struct number num1; num1.a = 10; num1.b = 20; struct number num2 = { 50, 100 }; cout << num1.a << endl; cout << num2.a << endl; c.a = 1000; cout << c.a << endl; } ``` ### 클래스와 객체 - 객체 : 클래스로 만들어 진 것 - 클래스 : 객체를 만드는 틀 - 붕어빵과 붕어빵 틀을 예로 들면 붕어빵 틀로 여러개의 붕어빵을 만들 수 있습니다. - 여기서 붕어빵 틀은 클래스고, 붕어빵은 객체가 됩니다. - 구조체와 비교 - 구조체 == 클래스 - 구조체 변수 == 객체 #### c++ 구조체 - c에서의 구조체와 다르지 않습니다. - 다만 c++에서는 구조체 안에 함수를 넣을 수 있습니다. - Human이라는 구조체를 만들면 다음과 같습니다. ``` #include #include using namespace std; struct Human { string name; int age; string gender; }; int main(){ struct Human tom; tom.name = "톰"; tom.age = 30; tom.gender = "M"; cout << tom.age << endl; struct Human sam; struct Human bob; } ``` - 누군가가 실수로 나이를 1000등과 같이 넣어줄 수 있기 때문에 구조체 안에 함수를 만들어 이를 제어하고자 합니다. ``` struct Human { string name; int age; string gender; void setAge(int h_age) { if (h_age >= 0 && h_age <= 100) { age = h_age; } } } ``` - 위와 같이 바꾸면 함수를 사용해 우리가 정한 범위 안에 값이 들어오면 age변수에 대입하고 아니면 함수를 끝내도록 만들었습니다. - 그러나 이렇게 만들어 준다고 해서 문제가 해결되는 것은 아닙니다. - 아직 변수로 값을 넣어줄 수 있기 때문에 이를 막아줘야 합니다. ### 접근 제어 - 접근제어란 변수나 함수에 접근하는 것을 범위로 제한하는 것을 말합니다. ### 접근 제어 지시자 - public - private ``` #include #include using namespace std; struct Human { private: string name; int age; string gender; public: void setAge(int h_age) { if (h_age >= 0 && h_age <= 100) { age = h_age; } else { cout << "나이의 범위가 잘못 입력되었습니다."; } } int getAge() { return age; } void setName(string h_name) { name = h_name; } string getName() { return name; } void setGender(string h_gender) { gender = h_gender; } string getGender() { return gender; } }; int main(){ struct Human tom; //tom.name = "톰"; //tom.age = 30; //tom.gender = "M"; tom.setAge(60); cout << tom.getAge() << endl; struct Human sam; struct Human bob; } ``` - 문제 ``` #include #include using namespace std; struct Member { private: string loginId; string password; string name; string address; string email; public: void setLoginId(string m_loginId) { loginId = m_loginId; } string getLoginId() { return loginId; } void setPassword(string m_password) { password = m_password; } string getPassword() { return password; } void setName(string m_name) { name = m_name; } string getName() { return name; } void setAddress(string m_address) { address = m_address; } string getAddress() { return address; } void setEmail(string m_email) { email = m_email; } string getEmail() { return email; } }; int main() { struct Member harry; harry.setLoginId("harry"); harry.setPassword("harry1234?!"); harry.setName("김해리"); harry.setAddress("대전광역시 서구"); harry.setEmail("harry@gmail.com"); cout << harry.getLoginId() << endl; cout << harry.getPassword() << endl; cout << harry.getName() << endl; cout << harry.getAddress() << endl; cout << harry.getEmail() << endl; } ``` ## class ``` #include #include using namespace std; class Animal { string type; string color; int weight; public: void setColor(string a_color) { color = a_color; } string getColor() { return color; } }; int main() { Animal animalA; animalA.setColor("흰색"); cout << animalA.getColor() << endl; Animal animalB; } ``` # 2022.07.17 ## npos ``` string s1 = "hello"; string s2 = "q"; if(s1.find(s2) != string::npos) { cout << (int)s1.find(s2) << endl; } // 18,446,744,073,709,551,615 -> 정수로 형변환 하면 -1이 나온다. // string npos = -1 ``` ## this 포인터 - 클래스 내부에서 자기 자신을 가리킬 때 사용 ``` #include #include using namespace std; class TestClass { int test; public: TestClass() { cout << "생성자 호출" << endl; } ~TestClass() { cout << "소멸자 호출" << endl; } void print() { cout << this << endl; } }; int main() { TestClass a, b; cout << "a : " << &a << endl; cout << "b : " << &b << endl; a.print(); // &a b.print(); } ``` ## 생성자와 소멸자 - 생성자 : 객체를 초기화 시킨다. - 소멸자 : 객체가 할당받은 메모리를 해제한다. ``` TestClass{ TestClass(){ 생성자 객체가 생성될 때 실행될 명령어 } ~TestClass(){ 소멸자 객체가 소멸될 때 실행될 명령어 } } ``` - 예제 - 전역객체와 지역객체를 번갈아 주석해 놓고 실행해 결과를 확인해 봅시다. ``` #include #include using namespace std; class TestClass { int test; public: TestClass() { cout << "생성자 호출" << endl; } ~TestClass() { cout << "소멸자 호출" << endl; } }; TestClass global; //전역객체 void print() { cout << "print 함수 시작" << endl; TestClass local; // 지역객체 cout << "print 함수 끝" << endl; } int main() { cout << "main 함수 시작" << endl; print(); cout << "main 함수 종료" << endl; // 지역변수, 지역객체 : 선언시 생성되며, 소멸시기는 변수 혹은 객체가 선언된 함수가 종료될때 소멸 // 전역변수, 전역객체 : main함수 시작 전에 생성되며, main함수 종료 후 소멸 } ``` ``` #include #include using namespace std; int a = 10; int b(100); class Number { int a; int b; public: /* 불가능 Number() { a(0); b(0); } */ /* Number() { a = 0; b = 0; } */ Number() : a(0), b(0) { } /* Number(int x, int y) { a = x; b = y; } */ Number(int x, int y) : a(x), b(y) { } void setA(int n_a) { a = n_a; } int getA() { return a; } void setB(int n_b) { b = n_b; } int getB() { return b; } }; int main() { Number m; cout << m.getA() << endl; Number m2 = Number(10, 20); cout << m2.getA() << endl; } ``` ``` #include #include using namespace std; class Animal { string name; string color; string home; public: Animal() { } /* Animal(string n_name) { name = n_name; } */ Animal(string name) : name(name) { } Animal(string name, string color, string home) : name(name), color(color), home(home) { } void setName(string n_name) { name = n_name; } string getName() { return name; } void setColor(string n_color) { color = n_color; } string getColor() { return color; } void setHome(string n_home) { home = n_home; } string getHome() { return home; } }; int main() { Animal rabbit = Animal("토끼", "흰색", "숲속"); //rabbit.setName("호랑이"); cout << rabbit.getName() << endl; Animal tiger; tiger.setName("호랑이"); tiger.setColor("주황"); tiger.setHome("산속"); cout << tiger.getName() << endl; Animal fish = Animal("물고기"); // 클래스를 생성자 없이 만들면 기본 생성자가 안에 숨어 있습니다. // 기본 생성자 없이 매개변수를 받는 생성자를 만들어 주면, // 기본 생성자는 사라지고, 매개변수를 받는 생성자만 남습니다. // 객체를 생성할 때 반드시 인수를 넣어줘야지만 객체를 생성할 수 있습니다. } ``` ``` #include #include using namespace std; class Date { // year // month // day int year; int month; int day; // 기본 생성자 // year 받는 생성자 // year, month 받는 생성자 // year, month, day 받는 생성자 Date() { year = 0; month = 0; day = 0; } /* Date(int year): year(year) { } */ Date(int year): Date() { this->year = year; // this->year : 멤버변수, year : 매개변수 } Date(int year, int month):Date(year) { //this->year = year; this->month = month; } Date(int year, int month, int day):Date(year, month) { this->day = day; } }; int main() { } ``` # 2022.07.23 ## 정적 메서드 ## 정적 멤버 변수 ``` #include #include using namespace std; //int idCount = 1; class Color { int id; int red; int blue; int green; public: static int idCount; Color() : red(0), blue(0), green(0) {} Color(int red, int blue, int green): red(red), blue(blue), green(green){ id = idCount++; } int getId() { return id; } int getRed() { return red; } int getBlue() { return blue; } int getGreen() { return green; } static Color mixColor(Color a, Color b) { return Color(a.red + b.red, a.blue + b.blue, a.green + b.green); } }; int Color::idCount = 1; //int a = 10; // 초기화 : 새로운 변수를 만들고 값을 대입하는 것 // 대입 : 이미 만들어진 변수에 값 대입 /* Color mixColor(Color a, Color b) { //Color result = Color(a.getRed()+b.getRed(), a.getBlue()+b.getBlue(), a.getGreen()+b.getGreen()); //return result; return Color(a.getRed() + b.getRed(), a.getBlue() + b.getBlue(), a.getGreen() + b.getGreen()); } */ int main() { Color red = Color(10, 5, 2); Color blue = Color(1, 7, 9); cout << red.getRed() << " " << red.getId() << endl; cout << blue.getRed() << " " << blue.getId() << endl; //Color purple = red.mixColor(red, blue); Color purple = Color::mixColor(red, blue); cout << purple.getRed() << " " << purple.getId() << endl; Color::idCount = 10; cout << Color::idCount << endl; Color orange = Color(1, 2, 3); cout << orange.getId() << endl; Color brown = Color(1, 2, 3); cout << brown.getId() << endl; return 0; } ``` ## 상수형 메소드 ``` #include #include using namespace std; class Account { int money; public: Account(): money(0) {} Account(int money) : money(money) {} // 입금 void deposit(int amount) { money += amount; cout << amount << "원을 입금했습니다." << endl; } // 출금 void draw(int amount) { if (money >= 0) { money -= amount; } cout << amount << "원을 인출했습니다." << endl; } int getMoney () const { //money++; return money; } }; // 상수 메서드 int main() { // 함수의 매개변수에도 사용이 가능하다. // 메서드(함수, 클래스 안에 있는 함수, 생성자) // 리턴타입 함수이름 ()const{} Account a = Account(100); a.deposit(50); a.draw(30); cout << a.getMoney() << endl; // 120 /* a.getMoney(); a.getMoney(); a.getMoney(); a.getMoney(); a.getMoney(); cout << a.getMoney() << endl; */ Account b; b.deposit(100); cout << b.getMoney() << endl; return 0; } ``` ## 메서드 선언 및 정의 ``` class Storage { int x; int y; public: Storage(): x(0), y(0) {} Storage(int x, int y): x(x), y(y) {} int getX() const { return x; } int getY() const { return y; } }; ``` - 선언과 정의 ``` #include using namespace std; class Storage { int x; int y; public: Storage(); Storage(int x, int y); int getX() const; int getY() const; }; Storage::Storage() : x(0), y(0) {} Storage::Storage(int x, int y) : x(x), y(y) {} int Storage::getX() const { return x; } int Storage::getY() const { return y; } int main() { Storage a = Storage(5, 14); cout << a.getX() << " " << a.getY() << endl; } ``` # 2022.07.24 ``` #include using namespace std; class Number { int x, y; public: /* Number() { x = 0; y = 0; } */ Number() : x(0), y(0) {} Number(int a, int b) : x(a), y(b) { //x = a; //y = b; } int getX() const { return x; } int getY() const { return y; } }; Number sumNumber(Number a, Number b) { Number result = Number(a.getX()+b.getX(), a.getY()+b.getY()); return result; } Number minusNumber(Number a, Number b) { Number result = Number(a.getX() - b.getX(), a.getY() - b.getY()); return result; } int main() { Number a = Number(5, 9); Number b = Number(2, 5); Number c = sumNumber(a, b); // Number(7, 14); cout << c.getX() << " " << c.getY() << endl; } ``` # 동적할당 ## 변수 - new - delete ``` #include using namespace std; int a; // 프로그램이 시작될때 생성, 프로그램이 종료될때 소멸됩니다. void test(){ int b; // test()함수가 선언되는 시점에 생성, test()함수가 끝나면 소멸됩니다. } // a(전역변수)와 b(지역변수)가 있는데, 이 변수들은 언제 생성되고 언제 소멸될까요? // c언어 malloc, free // c++ new , delete int main() { test(); // 변수 초기화 int a = 10; int b(10); int c = int(10); // 동적할당으로 바꾸기 // 데이터타입 포인터변수 = new 데이터타입(값); int *d = new int(100); cout << d << endl; cout << *d << endl; *d = 5; cout << d << endl; cout << *d << endl; delete d; // 만약에 동적할당을 하고 메모리 해제를 안해줬다면? // 메모리를 해제하지 않아도 프로그램이 종료되면 다시 사용할 수 있다. // 메모리를 해제하지 않으면 프로그램이 실행되는 동안에는 그 만큼을 사용할 수 없다. } ``` ## 배열 ``` #include using namespace std; int a; // 프로그램이 시작될때 생성, 프로그램이 종료될때 소멸됩니다. void test(){ int b; // test()함수가 선언되는 시점에 생성, test()함수가 끝나면 소멸됩니다. } // a(전역변수)와 b(지역변수)가 있는데, 이 변수들은 언제 생성되고 언제 소멸될까요? // c언어 malloc, free // c++ new , delete class Number { int x, y; public: // 생성자 Number() : x(0), y(0) { cout << this << " Number()" << endl; } Number(int a, int b) : x(a), y(b) { cout << this << " Number(int a, int b)" << endl; } // 소멸자 ~Number() { cout << "~Number()" << endl; } int getX() const { return x; } int getY() const { return y; } }; int main() { /* test(); // 변수 초기화 int a = 10; int b(10); int c = int(10); // 동적할당으로 바꾸기 // 데이터타입 포인터변수 = new 데이터타입(값); int *d = new int(100); cout << d << endl; cout << *d << endl; *d = 5; cout << d << endl; cout << *d << endl; delete d; // 만약에 동적할당을 하고 메모리 해제를 안해줬다면? // 메모리를 해제하지 않아도 프로그램이 종료되면 다시 사용할 수 있다. // 메모리를 해제하지 않으면 프로그램이 실행되는 동안에는 그 만큼을 사용할 수 없다. // 배열 // [칸수] int* arr = new int[5]; // arr은 배열 포인터가 아니라 int하나를 가리키는 포인터 arr[0] = 1; arr[1] = 2; // 동적할당된 배열 초기화 int* arr1 = new int[5]{1, 2, 3, 4, 5}; cout; int test; cin >> test; cout << test << endl; // 값을 입력받아 동적할당된 배열의 칸수에 넣어주세요. // 배열의 칸 수에 변수를 넣어줄 수 있다. int n; cin >> n; int* ptr = new int[n]; // n의 값은 변하지만, 칸수는 변하지 않는다. //n++; // n = 3 ptr[0] = 1; ptr[1] = 2; ptr[2] = 3; ptr[3] = 4; ptr[4] = 5; ptr[10] = 100; cout << ptr[0] << " " << ptr[1] << " " << ptr[2] << endl; cout << ptr[3] << " " << ptr[4] << endl; cout << ptr[10] << endl; cout << ptr << endl; cout << sizeof(ptr) / sizeof(int) << endl; // 8 -> 2 cout << _msize(ptr) << endl; cout << _msize(ptr) / sizeof(int) << endl; //c , sizeof delete ptr; // 배열의 첫번째 칸을 해제합니다. delete []ptr // 배열전체를 해제할 수 있다. */ // 객체에 동적할당 // new cout << "메임함수 시작" << endl; // 정적할당 객체 Number a; Number b = Number(2, 5); // 동적할당 객체 Number* c = new Number(4, 2); Number* d = new Number(0, 5); cout << a.getX() << " " << a.getY() << endl; cout << c->getX() << " " << c->getY() << endl; delete c; delete d; cout << "메인함수 끝" << endl; } ``` # 2022.07.30 ## 얕은 복사 / 깊은 복사 ``` // 얕은 복사 int* a = new int(3); // int공간의 주소값 int* b = a; // a에 들어있는 주소값 // int를 담는 공간과 그 공간에 들어있는 값이 복사된 것이 아니라 // 주소값만 복사되었다. *a = 100; cout << *a << endl; cout << *b << endl; delete a; // 깊은 복사 int* c = new int(3); int* d = new int(*c); *c = 100; cout << *c << endl; // 100 cout << *d << endl; // 3 delete c; delete d; ``` ## 상속 ``` #include using namespace std; class Parent { public: int pn; void parentFunc() { cout << "부모 클래스" << endl; } }; class Child : public Parent{ public: int cn; void childFunc() { cout << "자식 클래스" << endl; } }; class GrandChild : public Child{ public: int gn; void grandFunc() { cout << "손자 클래스" << endl; } }; int main() { // 상속 // 어떤 클래스의 멤버(변수, 메서드)를 다른 클래스(상속받는 클래스)에 // 물려주는 것 // 부모 클래스 : 물려주는(상속하는) 클래스 // 자식 클래스 : 물려받는(상속받는) 클래스 // 부모가 자식에 포함 / (자식이 부모에 포함) // 부모 클래스, 기본 클래스, 상위 클래스 // public // 자식 클래스, 파생 클래스, 하위 클래스 // class 자식클래스 : public 부모 클래스{}; Parent mom; mom.pn = 50; cout << mom.pn << endl; // 50 mom.parentFunc(); Child son; son.cn = 28; cout << son.cn << endl; // 28 son.childFunc(); son.pn = 58; cout << son.pn << endl; // 58 son.parentFunc(); cout << mom.pn << endl; // 50 GrandChild kid; kid.gn = 5; cout << kid.gn << endl; kid.grandFunc(); kid.childFunc(); kid.cn = 30; cout << kid.cn << endl; kid.parentFunc(); kid.pn = 60; cout << kid.pn << endl; return 0; } ``` ### 문제 ``` #include #include using namespace std; class Person { public: string name; int age; void personFunc() { cout << "이름은 " << name << " 이고, 나이는 " << age << "살 입니다." << endl; } }; class Student : public Person{ public: string school; int number; void studentFunc() { cout << "학교는 " << school << "이고, 학번은 " << number << "번 입니다." << endl; } }; int main() { Person a; a.age = 10; a.name = "sam"; a.personFunc(); Student b; b.school = "둔산초"; b.number = 31; b.studentFunc(); b.age = 12; b.name = "철수"; b.personFunc(); return 0; } ``` ## 접근 제어자 |접근제어자|클래스 내부|클래스 외부|자식 클래스| |---|---|---|---| |public| O | O | O| |protected| O | X | O | |private| O | X | X | ### protected - private과 마찬가지로 클래스 밖에서는 사용이 불가는하다. - 대신 클래스를 상속받는 자식 클래스에서는 사용이 가능합니다. - 부모 클래스 ``` class Parent { public: int pn; void parentFunc() { cout << "부모 클래스" << endl; } private: int pnPrivate; protected: int pnProtected; }; ``` - main ``` Parent mom; mom.pn = 50; // public 변수 mom.pnProtected = 1; // protected멤버이기 때문에 외부에서 접근 불가 mom.pnPrivate = 2; // private멤버이기 때문에 접근불가 ``` ### 상속 받는 클래스 뒤에 오는 접근제어자 - 아래의 코드에서 보이는 접근제어자를 의미합니다. ``` class Child : public Parent{}; ``` - 여기서 public의 의미는 부모 클래스에 있는 멤버들의 접근 제어자를 그대로 사용하겠다는 의미입니다. ``` Child son; son.cn = 28; // public 변수 son.pnProtected = 11; // 부모 클래스를 public으로 상속받았기 때문에 똑같이 protected로 적용되어 접근 불가 son.pnPrivate = 12; // private 이기에 접근 불가 ``` - protected와 private모두 사용이 가능하지만 일반적으로 public을 가장 많이 사용합니다. ### 문제 ```c #include using namespace std; class Animal { public: int age; void walk() { cout << "걷는다." << endl; } }; class Dog : protected Animal{ // protected로 상속 받았기 때문에 main함수에서 부모 클래스에 있는 멤버를 더이상 사용할 수 없습니다.(public -> protected) public: void bark() { cout << "짖는다." << endl; } }; class Eagle : public Animal{ public: void fly() { cout << "하늘을 난다." << endl; } }; int main() { Dog a; a.age = 5; a.walk(); a.bark(); Eagle b; b.age = 7; b.walk(); b.fly(); return 0; } ``` ## 생성자 - 주석을 먼저 제거하고 실행해 보세요. ``` class Parent { public: /* Parent() { cout << "부모 클래스 생성자" << endl; } */ Parent(int a, int b) { cout << "부모 클래스 생성자" << endl; } int pn; void parentFunc() { cout << "부모 클래스" << endl; } private: int pnPrivate; protected: int pnProtected; }; class Child : public Parent{ public: /* Child() : { cout << "자식 클래스 생성자" << endl; } */ Child() : Parent(10, 20) { cout << "자식 클래스 생성자" << endl; } int cn; void childFunc() { pnProtected = 7; cout << "자식 클래스" << endl; cout << "pnProtected : " << pnProtected << endl; } }; ``` - main ``` Child son; ``` # 2022.07.31 ## 멤버 재정의 - 재정의 : 같은 이름의 멤버를 정의하는 것을 의미합니다. ### 멤버 변수 ```c #include using namespace std; class Parent { public: int a = 5; }; class Child :public Parent{ public: int a = 100; }; int main() { // 멤버 재정의 Parent mom; Child son; cout << mom.a << endl; // 5 cout << son.a << endl; // 100 , a = 5(부모) / a = 100(내꺼) -> 우선 // 자식 클래스에 선언된 멤버가 부모 클래스에 선언된 멤버보다 우선 cout << son.Parent::a << endl; return 0; } ``` ## 멤버 메서드 - 멤버변수와 동일하게 적용됩니다. ``` #include using namespace std; class Parent { public: int a = 5; void test() { cout << "부모 클래스" << endl; } }; class Child :public Parent{ public: int a = 100; void test() { cout << "자식 클래스" << endl; } }; int main() { // 멤버 재정의 Parent mom; Child son; cout << mom.a << endl; // 5 cout << son.a << endl; // 100 , a = 5(부모) / a = 100(내꺼) -> 우선 // 자식 클래스에 선언된 멤버가 부모 클래스에 선언된 멤버보다 우선 cout << son.Parent::a << endl; mom.test(); son.test(); // 상속받는 test() / 내 test() -> 우선 son.Parent::test(); return 0; } ``` ## 정적 바인딩 ``` #include using namespace std; class Parent { public: int a = 5; void test() { cout << "부모 클래스" << endl; } }; class Child :public Parent{ public: int a = 100; void test() { cout << "자식 클래스" << endl; } void testChild() { cout << "testChild" << endl; } }; int main() { // 멤버 재정의 Parent mom; Child son; cout << mom.a << endl; // 5 cout << son.a << endl; // 100 , a = 5(부모) / a = 100(내꺼) -> 우선 // 자식 클래스에 선언된 멤버가 부모 클래스에 선언된 멤버보다 우선 cout << son.Parent::a << endl; mom.test(); son.test(); // 상속받는 test() / 내 test() -> 우선 son.Parent::test(); // 포인터 int a; int* ptr = &a; // 포인터 변수의 타입과 가리키고자 하는 변수의 자료형이 일치 // 포인터 변수 만들기 Parent* ptrP = &mom; // parent / parent Parent* ptrC = &son; // parent / child // 포인터 변수가 Child클래스가 아닌 Parent클래스로 만들어졌기 때문에 // Parent클래스에 있는 멤버에만 접근이 가능하다. cout << ptrC->a << endl; ptrC->test(); //ptrC->testChild(); // parent클래스에는 없는 메서드이기 때문에 에러발생 // 동적할당 Child* cPtr = new Child(); // cPtr에 들어있는 주소값이 pPtr에도 들어가게 된다. Parent* pPtr = cPtr; // 동적할당한 객체를 똑같이 가리켜라 라는 의미가 된다. // 정적 바인딩 // 바인딩 : 메서드를 호출했을 때, 여러개의 메서드중 어느 메서드를 실행해야하는지 결정하는 것을 말합니다. cPtr->test(); // child::test() pPtr->test(); // parent::test() // 정적 : 컴파일 타임에 결정 Child* ptrPC = &son; //Child* ptrPP = &mom; // 자식 클래스를 가리키는 포인터는 부모 클래스를 가리킬 수 없다. return 0; } ``` ## 가상함수, 동적 바인딩, 오버라이딩 - 문제 ``` Weapon클래스를 만들어 주세요 public - 생성자(int power){ // 받아온 power를 멤버 power에 대입 공격력 power인 무기 } - attack(){ "공격합니다." } protected: - int power Sword 클래스 : public Weapon public - 생성자(int power){ 공격력 power인 칼입니다. } - attack(){ "칼로 공격합니다." } Spear 클래스: public Weapon public - 생성자(int power, string horse){ 공격력 power인 창입니다. } - attack(){ "창으로 공격합니다." } private: ride(){ "horse 말에 타 창으로 공격합니다. } string horse; ``` - 정답 ``` #include #include using namespace std; class Weapon { public: Weapon(int power){ this->power = power; cout << "공격력 " << power << "인 무기" << endl; } virtual void attack() { cout << "공격합니다." << endl; } virtual ~Weapon() { cout << "weapon 소멸" << endl; } protected: int power; }; class Sword :public Weapon{ public: Sword(int power) : Weapon(power) { cout << "공격력이 " << power << "인 칼입니다." << endl; } void attack() { cout << "칼로 공격합니다." << endl; } ~Sword() { cout << "Sword 소멸" << endl; } }; class Spear : public Weapon{ public: Spear(int power, string horse):Weapon(power), horse(horse) { this->horse = horse; cout << "공격력이 " << power << "인 창입니다." << endl; } void attack() { cout << "창으로 공격합니다." << endl; } ~Spear() { cout << "Spear 소멸" << endl; } private: string horse; void ride() { cout << horse << "말에 타 창으로 공격합니다." << endl; } }; int main() { Weapon *weapon = new Spear(40, "말"); // spear() delete weapon; /* // 가상함수 Sword sword(10); Spear spear(30, "홀스"); sword.attack(); // attack / attack spear.attack(); Weapon* curWeapon; curWeapon = &sword; curWeapon->attack(); // 오버라이딩 : 부모의 가상함수를 재정의 하는 것 */ return 0; } ```

게시글 상세