[c++/cpp] 함수 포인터, 구조체 등

190618(1일차)
교육을 받으면서 노트필기 했던 내용을 날것 그대로 업로드합니다.

 

 

---

c++ 언어 == 절차적언어 + 객체지향언어

 

 

#include <iostream>

using namespace std;

 

int main() {

    cout << "Hello" << endl;

    std::cout << "Hi" << std::endl; // ::을 범위 지정자라고 한다.

    return 0;

}

 

- bool형 : 참, 거짓을 저장하는 형식 (1 이상의 값은 항상 true) (0은 false)

 

http://opensource.samsung.com/reception.do

 

#include <iostream>

using namespace std;

 

 

enum flag{a=1,b,c,d};

int main() {

    //flag f1 = 5;//불가능

    flag f2 = flag(5); // 또는 (flag)5도 가능하다.

 

    int i = (int)32.3;

    int j = int(32.3);

}

 

---

 

함수포인터를 반환하고 싶을 때 typedef를 사용하면 가능하다.

 

---

 

 

---

 

 

- 함수의 프로토타입을 선언할 때도 typedef를 활용할 수 있다.

 

---

 

인트형을 반환하는 함수 포인터를반환하는 함수

 

---

 

인트형을 반환하고 int,int를 매개변수로 같는 함수의 포인터를 반환하는 func2함수.

 

---

 

#include <iostream>

using namespace std;

typedef int i;

typedef i ia[3];// int형 3개짜리 타입 a

typedef ia* pia; //ia를 가리키는 pia라는 포인터타입

typedef ia iaa[2]; // int형 3개짜리가 2개인 2차원 배열타입

 

typedef int i_t;

typedef i_t fi_t(int, int); // int를 리턴하는 함수타입.

typedef fi_t* pfi_t; //밑에 있는 func_t와 같은 타입이다.

 

typedef int(*func_t)(int, int);

 

int(*func2())(int, int);

 

 

 

// add함수의 주소를 리턴하는 함수를 만들어라

fi_t add;

func_t func() {

    return add;

}

int(*func2())(int, int) {

    return add;

}

 

int main() {

    i a; //==int i

    

    ia arr; // int arr[3] 과 동일하다.

 

    pia p; // int (*p)[3];

    iaa b;//int b[2][3];

    p = b;

 

    cout << func()(10, 5) << endl;

 

    return 0;

}

int add(int a, int b) { return a + b; }

 

add 함수의 주소를 리턴하는 타입을 정의하고 사용한다.

 

 

 

 

---

 

/*

선언된 것을 typedef로 정의하시오.

char *

char *      [10]

char *(* )[10]

char*(*())[10

char*(*(*)())[10]

*/

typedef char* cp;

typedef cp cpArr10[10];

typedef cpArr10 *cpArr10p;

typedef cpArr10p cpa10fnc();

typedef cpa10fnc* c1fp;

 

---

 

- 구조체 (c와 동일)

---

- 포인터

 

    char **a;

    char ***ap = &a;

 

    char *b[2];

    char **bp = b;

 

    char c[2][3];

    char (*cp)[3] = c;

 

    char *d[2][3] = { "aa","bb","cc","dd","ee","ff" };

    char*(*dp)[3] = d;

 

    char(*e)[2][3]; // 2x3짜리 2차원 배열을 한번에 보는 포인터

    char(**ep)[2][3] = &e;

 

    char(*f[2])[3];//char형 3개짜리 배열을 가리키는 포인터가 2개인배열이 f다.

    char(**fp)[3]=f;

 

 

#include <iostream>

#include <cstring>

using namespace std;

int main() {

    char a[] = "a1b2";

    void* p = a;

    //p를 사용하여 a를 출력하시오

    //p++를 사용하여 b를 출력하시오.

 

    //*p++ == *(p++)

    char* pp = (char*)p;

    cout << *(++pp) << endl;

    cout << *(char*)p << endl;

    cout << *((char*)p+1) << endl;

 

    return 0;

}

 

 

- 래퍼런스 (변수이름, 같은 상자에 다른 이름을 붙인다.)

래퍼런스 변수는 선언후 바로 초기화를 해주어야한다.

int main() {

    int num1 = 10;

    int &ref = num1;

    ref = 20;

    cout << num1 << endl; // 20

 

    return 0;

}

 

 

 

#include <iostream>

#include <cstring>

using namespace std;

void swap2(int &a, int &b);

 

int main() {

    int a=10;

    int& ra = a; // 반드시! 초기화가 필요함! 그냥 선언만 할 수 없다.

    int* pa = &a;

 

    cout << a << endl;

    cout << ra << endl;

    cout << *pa << endl;

 

    cout << &a << endl;

    cout << &ra << endl;

 

    int& ra2 = ra;

    cout << &ra2 << endl;

 

    int* &rpa = pa;

    cout << rpa << endl;

    int c = 10, b = 5;

    swap2(c, b); // c에서는 못바꾼다. c++에서는 가능하다.

    cout << c<<" ,"<< b << endl;

    return 0;

}

void swap2(int &a, int &b) {

    int t;

    t = a;

    a = b;

    b = t;

}

 

 

 

#include <iostream>

#include <cstring>

using namespace std;

 

int& func1(int& rev) {

    rev = 10;

    return rev;

}

int func2(int& rev) {

    rev = 20;

    return rev;

}

int func3(int& rev) {

    rev = 10;

    return rev;

}

int& func4(int rev) {

    rev = 10;

    return rev;

}

 

int main() {

    int a = 20;

 

    int& rlt4 = func4(a); // 함수 종료시 rev는 사라짐.(그래서 쓰레기값 출력)

    cout << rlt4 << endl;

 

    //int rlt3 = func3(a); // 상수는 일반 변수로 가능

    //cout << rlt3 << endl;

 

    const int& rlt2 = func2(a); // 상수는 const참조자로 가능

 

    /*int rlt = func1(a); // 참조자(레퍼런스) 변수는 여러개로 처리가능.

    cout << rlt << endl;*/

    return 0;

}

 

 

    int a = 10;

    int* p = &a;

    int* (&rp) = p;

    int** pp = &p;

    int**(&rpp) = pp;

 

void swap3(int*&rpa, int*&rpb) {

    int tmp = *rpa;

    *rpa = *rpb;

    *rpb = tmp;

}

int main() {

    

    int a = 10, b = 5;

    int*pa = &a;

    int*pb = &b;

 

    swap3(pa, pb);//함수콜은 그대로 두고 swap3에서 a,b를 바꾸시오.

    cout << a << " , "<<b << endl;

    //int a = 10;

    //int* p = &a;

    //int* (&rp) = p;

    //int** pp = &p;

    //int**(&rpp) = pp;

 

    return 0;

}

 

---

 

- new / delete

메모리할당 합니다. 메모리 반납합니다.

- 함수 오버로딩 : 같은 이름의 함수를 여러개 만들어 쓸 수 있는 기능.

함수명이 같으면서 매개변수가 다르거나 매개변수 타입이 다른 경우 (반환타입과 변수명은 관련없다.)

- 함수 매개변수 default값 사용 가능.

 

- 인라인 함수 : 컴파일 시점에 삽입된다. 사용되는 위치에 코드 형태로 삽입된다.

함수호출이 생략되므로 성능향상을 기대할 수 있다.

- 매크로 함수 : 컴파일 전단계에서 코드로 치환된다.

매크로 이름은 오버로딩 될 수 잆다. 재귀 불가하다. 

 

- 파일 나눠서 컴파일하기, 헤더파일 사용하기

 

- 객체지향 개념에 대해서 공부했다.