130826.15일차

|

#include "130826.h"



// 가상 소멸자



/*

class CellPhone

{

char model[12];

public : 

CellPhone( char * model = "no" );

char * getModel();

virtual ~CellPhone();

};

CellPhone::CellPhone( char * model ) {

strcpy( this->model,model );

}

char * CellPhone::getModel() {

return model;

}

CellPhone::~CellPhone() {

puts("CellPhone 소멸자");

}





class CaPhone : public CellPhone

{

int pixel;

public :

CaPhone( char * model = "no", int pixel = 0 );

int getPixel();

virtual ~CaPhone();

};

CaPhone::CaPhone( char * model, int pixel ) : CellPhone ( model ) {

this->pixel=pixel;

}

int CaPhone::getPixel() {

return pixel;

}

CaPhone::~CaPhone() {

puts("CaPhone 소멸자");

}



class Mp3Phone : public CaPhone 

{

int chord;

public : 

Mp3Phone( char * model = "no", int pixel = 0, int chord = 0 );

int getChord();

virtual ~Mp3Phone();

};

Mp3Phone::Mp3Phone( char * model, int pixel, int chord ) : CaPhone ( model , pixel ) {

this->chord=chord;

}

int Mp3Phone::getChord() {

return chord;

}

Mp3Phone::~Mp3Phone() {

puts("Mp3Phone 소멸자");

}



void main()

{

Mp3Phone kim( "갤럭시", 700, 64 );

printf("모 델 명 : %s\n", kim.getModel() );

printf("화    소 : %d\n", kim.getPixel() );

printf("화    음 : %d\n", kim.getChord() );


puts("");


Mp3Phone * ap = new Mp3Phone( "아이폰", 700, 64 );

printf("모 델 명 : %s\n", ap->getModel() );

printf("화    소 : %d\n", ap->getPixel() );

printf("화    음 : %d\n", ap->getChord() );


delete ap;

puts("");



CellPhone * bp = new Mp3Phone("옵티머스", 1000, 128);

printf("모 델 명 : %s\n", bp->getModel() ); // virtual 쓰면 소멸자를 다 호출함. 사용을 못할뿐

// 이게 가상 소멸자

//printf("화    소 : %d\n", bp->getPixel() );

//printf("화    음 : %d\n", bp->getChord() );

delete bp;

puts("");


}


*/







// Template

/*

using namespace std;



template <class T1, class T2, class T3>

T3 hap( T1 a, T2 b);

template <class T1, class T2, class T3>

T3 cha( T1 a, T2 b);

template <class T1, class T2, class T3>

T3 gop( T1 a, T2 b);

template <class T1, class T2, class T3>

T3 mok( T1 a, T2 b);





void main() {


cout << hap < int , char , int > (5,'a') << endl;

cout << hap < int , double , double >(5,5.2) << endl;

cout << cha < double , int , double > (6.7,3) << endl;

cout << gop < int , int , int > (5,2) << endl;

cout << setiosflags(ios::fixed) << setprecision(2) << mok < int , int , int > (5,2) << endl;



}



// 템플릿의 핵심은 만들때 자료형을 정하지 않고 main에서 정한다. 


template <class T1, class T2, class T3>

T3 hap( T1 a, T2 b){

return a+b;

}

template <class T1, class T2, class T3>

T3 cha( T1 a, T2 b){

return a-b;

}

template <class T1, class T2, class T3>

T3 gop( T1 a, T2 b){

return a*b;

}

template <class T1, class T2, class T3>

T3 mok( T1 a, T2 b){

return double(a)/b;

}

*/





//CLASS 를 이용한 template


/*

using namespace std;


template <class T1, class T2, class T3>

class Calc

{

public : 

T3 hap( T1 a , T2 b );

T3 cha( T1 a , T2 b );

T3 gop( T1 a , T2 b );

T3 mok( T1 a , T2 b );

};

template <class T1, class T2, class T3>

T3 Calc< T1 , T2 , T3 >::hap( T1 a , T2 b )

{

return a+b;

}

template <class T1, class T2, class T3>

T3 Calc< T1 , T2 , T3 >::cha( T1 a , T2 b )

{

return a-b;

}

template <class T1, class T2, class T3>

T3 Calc< T1 , T2 , T3 >::gop( T1 a , T2 b )

{

return a*b;

}

template <class T1, class T2, class T3>

T3 Calc< T1 , T2 , T3 >::mok( T1 a , T2 b )

{

return double(a)/b;

}



void main()

{

Calc < int, int, int > m;

cout << "합 : " << m.hap(5,2) << endl;

cout << "차 : " << m.cha(5,2) << endl;

cout << "곱 : " << m.gop(5,2) << endl;

cout << "몫 : " << m.mok(5,2) << endl;



Calc < int, double, double > w;

cout << "합 : " << m.hap(5.2,2) << endl;

cout << "차 : " << m.cha(5,2.4) << endl;

cout << "곱 : " << m.gop(5,2.6) << endl;

cout << "몫 : " << m.mok(5,2.2) << endl;

}


*/







/*


STL ( Standard Template Library )



반복자(iterator)를 가지고 동작하는 C++ 표준 라이브러리의 일부분


컨테이너는 동일한 타입의 객체를 저장, 관리할 목적으로 추상화한 클래스


종류

표준 시퀀스 컨테이너 vecter, string, deque, list 선형방식의 컨테이너

표준 연관 컨테이너 set, multiset, map, multimap 비선형 방식의 컨테이너


저장 방식에 따라

-연속 메모리 기반 컨테이너 보통 데이터 여러개가 하나의 메모리 단위에 저장

배열 기반 컨테이너(array-based container)라고도 함

노드 기반 컨테이너 데이터 하나를 하나의 메모리 단위에 저장


반복자

반복자는 컨테이너에 저장된 객체들에 접근하고 순회하는 일반화된 방법을 제공


*/





/* 


VECTOR


가장 많이 사용

시퀀스 컨테이너 / 연속 메모리 기반 컨테이너


데이터가 삽입될 수록 기존 메모리를 삭제하고 새로운 메모리를 재할당한다.

비효율적인 재할당을 막기 위해서 미리 여유 메모리 공간을 확보한다.

operator[]() 함수를 가지고 있다


==  !=  ++  *  -> 연산자 함수가 정의 되어 있다.




http://www.cplusplus.com/reference/



*/





/*

#include <vector>



using namespace std;




void main()

{

vector <int> v(5);

//v.reserve(5)


v.push_back(10);


// 방의 갯수가 확보된 상태에서만 사용하기

v[0] = 10;

v[1] = 20;

v[2] = 30;

v[3] = 40;

v[4] = 50;


cout << "용량 : " << v.capacity() << endl; // 여분의 크기

cout << "크기 : " << v.size() << endl; // 현재 크기


// 출력

int i;

for ( i=0 ; i<v.size() ; i++ ) {

cout << "v[" << i << "] : " << v[i] << endl;

}

cout << endl;


// 반복자

vector <int>::iterator iter;


for ( iter = v.begin() ; iter < v.end() ; iter++ ) { // 처음 주소를 얻어와서 한칸씩이동하면서 반복

cout << * iter << endl;

}

cout << endl;



// 연산자

iter = v.begin();

iter += 3; // 3칸 이동한곳의 데이터

cout << * iter << endl;


}


*/




/* 


리스트 ( list )


시퀀스 컨테이너 / 노드 기반 컨테이너

삽입, 삭제가 자주 발생할 때 유용

이중 연결 리스트로 구현되어 있어 양방향 반복자를 제공

앞 뒤로 삽입이 모두 가능

operator[]() 함수가 없다.


*/



/*

#include <vector>

#include <list>


using namespace std;

void main()

{

list <int> lt;

lt.push_back( 40 );

lt.push_back( 50 );

lt.push_back( 60 );


lt.push_front( 30 );

lt.push_front( 20 );

lt.push_front( 10 );




cout << "크기 : " << lt.size() << endl;



// 반복자로 출력

list <int>::iterator iter;

for ( iter = lt.begin() ; iter != lt.end() ; iter++ ) {

cout << * iter << endl;

}

cout << endl;



// 양방향 반복자

iter = lt.end();

while ( true )

{

if ( iter == lt.begin() ) break;

iter--;

cout << * iter << endl;

}


cout << endl;


list <int>::reverse_iterator riter;

for ( riter = lt.rbegin() ; riter != lt.rend() ; riter++ ) {

cout << * riter << endl;

}


cout << endl;


// 삽입 

iter = lt.begin();

iter++;


lt.insert( iter , 100 );

for ( iter = lt.begin() ; iter != lt.end() ; iter++ ) {

cout << * iter << endl;

}

cout << endl;




// 삭제

iter = lt.begin();

iter++;

lt.erase(iter);

for ( iter = lt.begin() ; iter != lt.end() ; iter++ ) {

cout << * iter << endl;

}

cout << endl;



}


*/






/*


STRING


문자열을 다루는 전용 컨테이너


basic_string<char>의 typedef일 뿐이다.

시퀀스 컨테이너 / 연속 메모리 기반 컨테이너.

vector와 비슷한 특징을 갖는다.

operator[]() 한수를 가지고 있다. 

string 8bit, basic_string<char>의 typedef

wstring 16bit, basic_string<wchar>의 typedef

string과 wstring은 저장 바이트 수만 다를 뿐 모든 멤버와 기능은 같다


*/




/*

#include <vector>

#include <list>

#include <string>

using namespace std;



void main() 

{

string str = "Hello";


cout << str << endl;

str.push_back('H');

str.push_back('e');

str.push_back('l');

str.push_back('l');

str.push_back('o');


cout << str << endl;


for ( int i=0 ; i<str.size() ; i++ ) {

cout << str[i] ;

}


cout << endl;


//반복자

string::iterator iter;

for (iter = str.begin() ; iter < str.end() ; iter++ ) {

cout << * iter ;

}

cout << endl;


// char *

const char * s = str.c_str(); // const는 값을 변경하지 말라는 말

cout << s << endl;



// cin

//string str1;

//cout << "입력 : ";

//cin >> str1;

//cout << str1 << endl; 

// 입력 받기 귀찮으니까 주석



// find

cout << str.find('e') << endl;


// 대입 연산

string str2 = str;

cout << str2 << endl; 

}



*/





/* 


set / multiset


연관 컨테이너 / 노드 기반 컨테이너

양방향 반복자를 제공

균형 2진 트리인 레드-블랙 트리를 사용

데이터 값을 빠르게 검색하고자 할 때 유용


set 유니크(unique)한 데이커

multiset 중복된 데이터가 존재


*/



/*

#include <vector>

#include <list>

#include <string>

#include <set>

using namespace std;


void main()

{

set <int> s;

s.insert( 10 );

s.insert( 20 );

s.insert( 30 );

s.insert( 40 );

s.insert( 50 );


set <int>::iterator iter;

for ( iter = s.begin() ; iter != s.end() ; iter++ ) {

cout << * iter << endl;

}


cout << endl;




iter = s.find( 40 );

if ( iter != s.end() ) {

cout << * iter << endl;

} else { 

cout << "없음" << endl;

}

}


*/



/*


map multimap


연관 컨테이너 / 노드 기반 컨테이너

양방향 반복자를 제공

균형 2진 트리인 레드-블랙 트리를 사용

map은 key와 value의 쌍으로 구성된 데이터 셋의 집합

연관 컨테이너에서 유일하게 operator[] 연산자 함수 제공


map 유니크한 key

multimap 중복된 key가 존재


*/



/*

#include <vector>

#include <list>

#include <string>

#include <set>

#include <map>

using namespace std;


void main()

{

map <int,int> m;

m[0] = 90;

m[9] = 40;

m[5] = 20;

m[1] = 50;

m[3] = 80;


m.insert( pair<int,int>(4,100) ); // 동일한 index에 대입 안됨


map <int,int>::iterator iter;

for ( iter = m.begin() ; iter != m.end() ; iter++ ) {

cout << "key : " << (*iter).first << "\t" << "value : " << (*iter).second << endl;

}


}


*/



저작자 표시 비영리 변경 금지
신고

'Study > C, C++' 카테고리의 다른 글

130826.15일차  (0) 2013.08.26
130823.14일차  (0) 2013.08.26
130822.13일차  (0) 2013.08.22
130821.12일차  (0) 2013.08.22
130820.11일차  (0) 2013.08.22
130819.10일차  (0) 2013.08.22
Trackback 0 And Comment 0