6교시

// 동적메모리할당 

// 1. 왜동적메모리할당을사용하는가?

//    주로실행시간결정된값으로메모리를할당하기위해.

}

//--------------------------------------------------------------

void main()

{

        //C++

        int* p1 = new int;

        int* p2 = new int[10];

        delete p1;

        delete[] p2;

        int* p3 = new int(3);  // 3으로초기화

        // 2차원배열의주소는1차원배열포인터로가르키면된다.

        int(*p4)[10] = new int[10][10];              // 2차원배열형태로.

        int* p6 = new int;

        free(p6);              // undefined

        int* p7 = new int[10];

        delete p7;             // undefined

        int n;

        cout << "학생수를넣어주세요. >>";

        cin >> n;

        // 학생수만큼의메모리를할당하고싶다.   

        //int jumsu[n]; 
        // 배열의크기는변수가될수없다. 상수이어야한다.

        int* jumsu = (int*)malloc( sizeof(int)*n );         

}

// 값을리턴하는함수

// 1) bulit in type 의값을리턴( ex. int foo() )

//      => 리턴값은상수취급된다.

// 2) user type의값을리턴( ex. Point foo() )

//      => 임시객체를리턴한다.( 일부컴파일러는임시객체를상수취급하기도한다.)

4교시

// 레퍼런스문법총정리

int main()

{

        int  n = 10;

        int* p = &n;

        int& r = n;            //

        r = 20;

        cout << n << endl;     // 20

        int& r2;               // ? Error. 반드시초기화되어야한다.

        //----------------------------------------------------

        int*& rp = p;  // ok. 포인터의별명

        int&* pr = r;  // 별명의주소?  error

}

// 2. 원리: 내부적으로대부분의컴파일러는포인터를사용한다.

//         "자동으로역참조되는포인터" 라고도부른다.

void inc1( int x )     { ++x; }

void inc2( int* p )    { ++(*p); }

void inc3( int& r ) { ++r; }

void main()

{

        int a = 10;

        int b = 10;

        int c = 10;

        inc1( a );             // 실패- call by value

        inc2( &b );            // ok. call by pointer

        inc3( c );             // ok. call by reference int &r = c;

        cout << a << endl;     // 10

        cout << b << endl;     // 11

        cout << c << endl;     // 11

}

// 3. 함수호출과레퍼런스

// 인자값을변경하는함수-> 포인터가좀더좋다. ( 명확하다. )

// 인자값이바뀌지않은함수

// 1) bulit in type => const T&가오히려나쁘다.(4byte사용, 레지스터사용못함.)
//                     call by value를사용.

// 2) user type     => const T&

struct AAA

{

        int data[10000000];   // 1M라고가정.

};

void foo( const AAA& a )   // call by value :  값을 변경하지 않을것 이다.

{                          // 단점: 메모리 사용량이 2개가 된다.

        a = 20;            // const& : 메모리 사용량을 줄이고 값을 변경하지 않게 한다.

}

void main()

{

        AAA x = 10;

        foo ( x );

        cout << x << endl;

}

3교시

// Namespace 문법에관해서

// 1. 개념

// 프로그램을논리적인구조로구별하기위한문법

// 아울러이름충돌을막을수있다.

// 2. 함수접근방법

//    1. 완전한이름사용

//    2. using 선언(Declaration 사용)

//    3. using 지시어(Directive 사용)

// 4. namespace 별명(Alias) 과 라이브러리의선택적사용

// 5. namespace 함수의외부구현- 클래스보다가벼운이름을묶어놓는공간

// 7. namespace std

2교시

// C++ explicit casting 개념

// 1. C의캐스팅은대부분성공한다. 하지만너무나위험하고, 버그가많다.

// 2. C++은용도에따라4가지의casting 연산자가제공된다.

// dynamic_cast : RTTI를위해존재.!! - 상속을알아야한다.

#include <iostream>

using namespace std;

int main()

{

        const int c = 10;

        int *p = (int*)&c;

        //int* p = static_cast<int*>(&c);
        // 당연히에러.. 말도안되는코드

        //int* p = reinterpret_cast<int*>(&c);
        //const를벗겨낼수없다. error

        //int* p = const_cast<int*>(&c);
        // ok. 동일type의객체에대해const속성을제거

        // 단, 지금처럼const 상수에는사용하지는않는다.const object에사용.

        *p = 30;

        cout << c << endl << *p << endl << &c << endl << p << endl;

}

/*

int main()

{

        int a = 0;

        double d = 3.4;

        //int n = d; 
        // 암시적변환가능. 하지만data의손실이발생한다.

        //static_cast : 위험하지않은이성적인변환만허용한다.

        static_cast : 위험하지않은이성적인변환만허용한다

        //double *p = (double*)&n;    // 암시적변환은불가능.

                                      // C의명시적변환은가능.

        // 결국template 함수의인자를명시적으로지정하고있는모양이다.

        //double* p = static_cast<double*>(&n);      // 허용해줄까? 에러!!

        double* p = reinterpret_cast<double*>(&n);
        // ok..대부분성공, C캐스팅과비슷.

        *p = 100;

}

*/

결론 : static_cast를 사용하여 형변환을 하자!!!

1 교시