130823.14일차

|

#include "130823.h"


/*

class Father

{

protected : 

int kor;

public : 

Father( int kor=0 );

void disp();

};

Father::Father( int kor ) {

this->kor = kor; 

}

void Father::disp() {

printf("국어 : %d\n", kor);

}




class Son : public Father

{

int eng;

public : 

Son(int kor=0, int eng=0);

void disp();

void dispAll();

};

Son::Son( int kor, int eng ) : Father( kor ) {

this->eng = eng;

}

void Son::disp() {

printf("영어 : %d\n", eng);

}

void Son::dispAll() {

printf("국어 : %d\n", kor);

printf("영어 : %d\n", eng);

}



void main()

{

Father * fa;

Son * so;



// 부모 클래스 객체 포인터 변수 = 부모 클래스 객체

fa = new Son( 20 );

fa->disp(); // 20

//fa->dispAll();


delete fa;


// 자식 클래스 객체 포인터 변수 = 자식 클래스 객체

so = new Son( 30, 40);

so->Father::disp(); // 30

so->disp(); // 40

delete so;


// 부모 클래스 객체 포인터 변수 = 자식 클래스 객체

fa = new Son(50,60); // 자동 형변환

fa->disp();

//fa->disAll();

delete fa;


// 자식 클래스 객체 포인터 변수 = 부모 클래스 객체

//so = new Father( 80 ); // 잘라서 넣으면 가능. 

so =(Son*) new Father( 80 ); // 강제 형변환

so->Father::disp();


delete so;


}



*/





// 함수 포인터

/*

double hap( int a, int b );

double cha( int a, int b );

double gop( int a, int b );

double mok( int a, int b );

void main()

{

int a=5, b=2;



// 함수를 이름으로 접근

printf("합 : %.2lf\n", hap(a,b) );

printf("차 : %.2lf\n", cha(a,b) );

printf("곱 : %.2lf\n", gop(a,b) );

printf("몫 : %.2lf\n", mok(a,b) );


printf("\n");

//함수를 포인터로 접근

double (*ap)( int , int );

ap = &hap; // ap = hap 이렇게 해도되고 안해도됨

printf("합 : %.2lf\n",(*ap)(a,b) );


//함수 포인터를 쓰면 간단해진다


ap = &cha;

printf("차 : %.2lf\n",(*ap)(a,b) );


ap = &gop; 

printf("곱 : %.2lf\n",(*ap)(a,b) );


ap = &mok; 

printf("몫 : %.2lf\n",(*ap)(a,b) );



}



double hap( int a, int b ) {

return (double)a+b;

}

double cha( int a, int b ) {

return (double)a-b;

}

double gop( int a, int b ) {

return (double)a*b;

}

double mok( int a, int b ) {

return (double)a/b;

}

*/





// 멤버 함수 포인터


/*

class Calc

{

int a, b;

public : 

Calc( int a=0, int b=0 );

int hap();

int cha();

int gop();

double mok();

};


Calc::Calc( int a, int b){

this->a=a;

this->b=b;

}

int Calc::hap() {

return a+b;

}

int Calc::cha() {

return a-b;

}

int Calc::gop() {

return a*b;

}

double Calc::mok() {

return (double)a/b;

}





void main() {

Calc c(5,2);

// 멤버함수를 이름으로 접근

printf("합 : %d\n", c.hap() );

printf("차 : %d\n", c.cha() );

printf("곱 : %d\n", c.gop() );

printf("몫 : %.2lf\n", c.mok() );

printf("\n");


// 멤버함수를 포인터로 접근

int (Calc::*ap)();

double (Calc::*bp)();

ap = &Calc::hap;

printf("합 : %d\n", (c.*ap)() );

ap = &Calc::cha;

printf("차 : %d\n", (c.*ap)() );

ap = &Calc::gop;

printf("곱 : %d\n", (c.*ap)() );

bp = &Calc::mok;

printf("몫 : %.2lf\n", (c.*bp)() );


printf("\n");



Calc * cp = new Calc(7,3);

printf("합 : %d\n", cp->hap() );

printf("차 : %d\n", cp->cha() );

printf("곱 : %d\n", cp->gop() );

printf("몫 : %.2lf\n", cp->mok() );

printf("\n");


ap = &Calc::hap;

printf("합 : %d\n", (cp->*ap)() );

ap = &Calc::cha;

printf("차 : %d\n", (cp->*ap)() );

ap = &Calc::gop;

printf("곱 : %d\n", (cp->*ap)() );

ap = &Calc::mok;

printf("몫 : %.2lf\n",(cp->*ap)() );


}


*/






// 멤버함수 포인터를 이용한 자식 클래스 멤버 접근 

/*

class Name

{

char name[12];

public : 

Name( char * nema = "no" );

void dispName();


void disp( Name * np, void (Name::*ap)() );


void disp( void (Name::*ap)() );

};

Name::Name( char * name )  {

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

strcpy( this->name , name );

}

void Name::dispName() {

printf("이름 : %s\n", name);

}

void Name::disp( Name * np, void (Name::*ap)() ) {

(np->*ap)();

}

void Name::disp( void (Name::*ap)() ) {

(this->*ap)();



}





class Year : public Name

{

int age; 

public : 

Year( char * name = "no", int age = 0 );

void dispYear(); // 나이 출력

};

Year::Year( char * name , int age ) : Name( name ) {

this->age = age;

}

void Year::dispYear() {

printf("나이 : %d\n", age);

}




class Body : public Name

{

double ki; 

public : 

Body( char * name = "no", double ki = 0 );

void dispBody(); // 키 출력

};

Body::Body( char * name , double ki ) : Name( name ) {

this->ki = ki;

}

void Body::dispBody() {

printf("키 : %.2lf\n", ki);

}




// 부모가 자식을 부르는걸 해보자


void main()

{

Year kim("김유신", 30);

kim.dispName();

kim.dispYear();


Body hong("홍길동", 170.5);

hong.dispName();

hong.dispBody();


printf("\n");


void (Name::*ap)();

ap = ( void(Name::*)() ) &Year::dispYear;

kim.disp( &kim, ap );

ap = ( void(Name::*)() ) &Body::dispBody;

hong.disp( &hong, ap );


printf("\n");


hong.disp( ap );

}


*/




// 가상함수와 다형성



/*


class CellPhone

{

char model[20];

public :

CellPhone( char * model = "no" );

virtual void disp(); // 모델명 출력  // 가상함수(각각 클래스에 있는 자기꺼 찍게됨)

void show();

};

CellPhone::CellPhone( char * model) {

strcpy( this->model, model);

}

void CellPhone::disp() {

printf("모 델 명 : %s\n", model);

}

void CellPhone::show() {

disp();

}







class CaPhone : public CellPhone

{

int pixel;

public : 

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

virtual void disp(); // 픽셀 출력

};

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

this->pixel = pixel;

}

void CaPhone::disp() {

printf("화    소 : %d\n",pixel);

}







class Mp3Phone : public CaPhone

{

int chord;

public : 

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

virtual void disp(); // 화음 출력

};

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

this->chord = chord;

}

void Mp3Phone::disp() {

printf("화    음 : %d\n",chord);

}






void main() {


CellPhone cp("Galaxy S3");

cp.show();


CaPhone ca("iPhone", 500);

ca.show();


Mp3Phone mp("G2", 600, 64);

mp.show();

}


*/




/* 


순수 가상함수 / 추상 클래스

순수 가상함수를 가지면 추상 클래스가 된다.

순수 가상함수는 구현하지 않는다.

객체를 생성할 수 없다.

항상 상속으로 구현된다.

상속 시 순수 가상함수는 빠짐없이 구현해야 한다.

*/


/*


class Name // 추상 클래스

{

char name[12];

public : 

Name( char * name = "no" );

void disp(); // 이름 출력


virtual void dispAll() = 0; // 순수 가상함수 / 구현하지 않는다

};

Name::Name(char * name) {

strcpy( this->name, name );

}

void Name::disp() {

printf("이름 : %s\n", name);

}






class Year : public Name

{

int age;

public : 

Year( char * name = "no" , int age = 0 );

void disp(); // 이름 출력

void dispAll();

};

Year::Year( char * name , int age ) : Name( name ) {

this->age = age;

}

void Year::disp() {

printf("나이 : %d\n", age);

}

void Year::dispAll() {}







class Body : public Year

{

double ki;

public : 

Body( char * name = "no" , int age = 0 , double ki = 0 );

void disp(); // 이름 출력

void dispAll();

};

Body::Body( char * name , int age , double ki ) : Year( name , age ) {

this->ki = ki;

}

void Body::disp() {

printf("키 : %.2lf\n", ki);

}

void Body::dispAll() {}




void main()

{

Year lee("이순신", 40 );

Body kim("김유신", 30, 170.5);

kim.Name::disp();

kim.Year::disp();

kim.disp();



}

*/







// 순수가상함수를 이용한 다형성 

class Shape

{

protected : 

int a, b; // 밑변 높이 or 반지름

double area;

public :

Shape( int a = 0 , int b = 0 , double area = 0 );

virtual void input() = 0; // 입력

virtual void calc() = 0; // 계산 

virtual void disp() = 0; // 출력

};

Shape::Shape( int a , int b , double area ) {

this->a = a;

this->b = b;

this->area = area;

}



class Rect : public Shape

{

public : 

Rect( int a = 0 , int b = 0 , double area = 0 );


void input();

void calc() ;

void disp() ;

};

Rect::Rect( int a , int b , double area ) : Shape( a , b , area ){

}

void Rect::input() {

puts("사각형의 넓이" );

printf( "밑변 : " );

scanf( "%d", &a );

printf( "높이 : " );

scanf( "%d", &b );

}

void Rect::calc()  {

area = a * b;

}

void Rect::disp() {

printf("넓이 : %.2lf\n", area );

}








class Tri : public Shape

{

public : 

Tri( int a = 0 , int b = 0 , double area = 0 );


void input();

void calc() ;

void disp() ;

};

Tri::Tri( int a , int b , double area ) : Shape( a , b , area ){

}

void Tri::input() {

puts("삼각형의 넓이" );

printf( "밑변 : " );

scanf( "%d", &a );

printf( "높이 : " );

scanf( "%d", &b );

}

void Tri::calc()  {

area = a * b / 2.;

}

void Tri::disp() {

printf("넓이 : %.2lf\n", area );

}









class Circle : public Shape

{

public : 

Circle( int a = 0 , int b = 0 , double area = 0 );


void input();

void calc() ;

void disp() ;

};

Circle::Circle( int a , int b , double area ) : Shape( a , b , area ){

}

void Circle::input() {

puts("원의 넓이" );

printf( "밑변 : " );

scanf( "%d", &a );

}

void Circle::calc()  {

area = a * a * 3.14;

}

void Circle::disp() {

printf("넓이 : %.2lf\n", area );

}





void main()

{

Shape * m[] = { new Rect, new Tri, new Circle };

int i;


for ( i=0 ; i<3 ; i++ ) {

m[i]->input();

m[i]->calc();

m[i]->disp();

}

//Rect r;

//Tri t;

//Circle c;


//r.input();

//r.calc();

//r.disp();

//t.input();

//t.calc();

//t.disp();

//c.input();

//c.calc();

//c.disp();



}





// 가상 소멸자


// Templete


// STL

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

'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

130822.13일차

|
헤더


#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <string.h>
#include <iostream>
#include <iomanip>




메인



#include "130822.h"




// Stack 구조

/*

#define MAX 3


class Stack

{

char data[MAX];

int top;

public:

void init(); // top을 0번쨰 스택으로 옮긴다. 데이터가 현재 없다.

void push( char ch );

char pop();


// 데이터가 넘으면 overflow

// 꺼낼 데이터가 없으면 underflow

};


void Stack::init() {

top = 0;

}


void Stack::push( char a ) {

if( top == MAX ) {

puts("overflow");

return;

} else {

data[top] = a;

top++;

}


char Stack::pop() {

if (top == 0 ) {

puts("underflow");

return NULL;

} else {

return data[ --top ];

//top--;

}

}




void main() 

{

Stack s;

s.init();

s.push('A');

s.push('B');

s.push('C');

s.push('D');


printf("%c\n",s.pop());

printf("%c\n",s.pop());

printf("%c\n",s.pop());

printf("%c\n",s.pop());

}


*/



// 복사 생성자와 멤버 동적할당

/*

class Person

{

char * name;

int age;

public:

Person( char * name = "no", int age = 0 );

Person( Person & m);

char * getName();

int getAge();

void disp();

~Person();

void operator = ( Person & m );

};


Person::Person( char * name, int age) {

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

strcpy(this->name,name);

this->age = age;

}

Person::Person( Person & m ) {

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

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

this->age = m.age;

}


char * Person::getName() {

return name;

}


int Person::getAge() {

return age;

}


void Person::disp() {

printf("주소 : %p\n",name);

}


Person::~Person(){

   delete name;

}


void Person::operator = ( Person & m ) {

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

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

this->age = m.age;

}


void main() 

{


Person kim("김유신",30);

printf("이름 : %s\n",kim.getName());

printf("나이 : %d\n",kim.getAge());

kim.disp();


printf("\n");


Person lee(kim); // 복사 생성자

printf("이름 : %s\n",lee.getName());

printf("나이 : %d\n",lee.getAge());

lee.disp();


// 복사 생성자와 operator = 

// 객체 뒤에 연산자가 올때만 가능

printf("\n");

Person park = kim;

printf("이름 : %s\n",park.getName());

printf("나이 : %d\n",park.getAge());

park.disp();


printf("\n");


Person hong;

hong = kim; // 이건또 안됨. Person hong에서 소멸

// operator = 으로 호출. 주소 복사

printf("이름 : %s\n",hong.getName());

printf("나이 : %d\n",hong.getAge());

hong.disp();


}

*/



// friend


// const


// 포함객체


// (직접 보기)





/* ★★★ 상속 Inheritance


아버지의 것은 내 것

접근 지정자 / 생성자 / 소멸자는 상속할 수 없다.

재활용 / 재사용으로 시간과 비용을 단출할 수 있다.


CellPhone 전화 기능

char model[20]; 모델명

char tel[20]; 전화번호


CaPhone 전화 기능 + 카메라 기능

int pixel; 픽셀


Mp3Phone 전화 기능 + 카메라 기능 + Mp3 기능

int chord; 화음


 

*/


// ★★★★★ 전화

/*  

class CellPhone { // 전화 기능

private : // 자식이 직접 접근할때는 protected, 부모에게 부탁할때는 private으로 둬도 된다.

char model[20];

char tel[30];

public :

CellPhone( char * model = "no", char * tel = "no" );

char * getModel();

char * getTel();


};


CellPhone::CellPhone( char * model , char * tel ) {

strcpy( this->model,model );

strcpy( this->tel,tel );

}


char * CellPhone::getModel() {

return model;

}


char * CellPhone::getTel() {

return tel;

}





class CaPhone : public CellPhone { // 카메라 기능 + 전화 기능

private : 

int pixel;

public : 

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

int getPixel();

};


CaPhone::CaPhone( char * model , char * tel , int pixel ) : CellPhone( model, tel ) { // : CellPhone() 부모호출 

//strcpy( this->model,model ); // 카메라 기능만 하려면 CellPhone이 해야하는 일을 넣으면 안된다.

//strcpy( this->tel,tel );

this->pixel = pixel;

}


int CaPhone::getPixel() {

return pixel;

}


// 초기화는 각자처리한다. 

// 기능별로 따로 구현.

// 부모부터 먼저 호출함. ( 초기화 때문에 )

// 부모에 초기값 없이 자식에게만 주소값 있으면 오류남.

// 부모 생성자에 초기값있어야함.






class Mp3Phone : public CaPhone { // 전화 기능 + 카메라 기능 + mp3기능

private : 

int chord;

public : 

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

int getChord();

};


Mp3Phone::Mp3Phone( char * model , char * tel , int pixel , int chord) : 

CaPhone( model, tel, pixel ) { 

this->chord = chord;

}


int Mp3Phone::getChord() {

return chord;

}






void main() {


//CellPhone cp("I-500","010-9491-5006");

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

//printf("전화번호 : %s\n", cp.getTel() );


//CaPhone ca( "I-500","010-9491-5006",500 );

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

//printf("전화번호 : %s\n", ca.getTel() );

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


Mp3Phone mp( "I-500","010-9491-5006",500,64 );

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

printf("전화번호 : %s\n", mp.getTel() );

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

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


}


*/



// 상속 방식

// public / protected / private


/*

class AA

{

private :

int aa;

protected : 

int ab;

public : 

int ac;

};




class BB : protected AA

{

private :

int ba;

protected :

int bb;

public : 

int bc;

};



class CC : public BB

{

private :

int ca;

protected :

int cb;

public : 

int cc;

void disp();

};



void CC::disp()

{

//aa = 10;  // private 이라 접근 못함

ab = 20;

ac = 30;

//ba = 40;  // private 이라 접근 못함

bb = 50;

bc = 60;

ca = 70; 

cb = 80; 

cc = 90;

}




void main() {


CC t;

//t.ac = 10; // BB클래스가 상속받을때 protected로 상속 받기 때문에 막힘

// 상속을 private으로 바꾸면 내 자식은 부모에게 아예 못가고 나만 갈 수 있음

t.bc = 20;

t.cc = 30;


AA m;

m.ac=10;

}

*/





// 오버라이드

// 오버로드(다중정의) // 오버라이드(재정의)


/*

class Name // 이름 관리

{

char name[12];

public :

Name( char * name="no");

void dispName(); // 이름 출력

void disp(); // 이름 출력

};


Name::Name( char * name ) {

strcpy( this->name, name );

}

void Name::dispName() {

printf("이름 : %s\n", name );

}


void Name::disp() {

printf("이름 : %s\n", name );

}





class Year : public Name // 이름 / 나이 관리

{

int age;

public : 

Year( char * name="no", int age=0 );

void dispYear(); // 나이 출력

void disp(); // 나이 출력

};


Year::Year( char * name, int age ) : Name( name ) {

this->age = age;

}


void Year::dispYear() {

printf("나이 : %d\n", age );

}


void Year::disp() {

printf("나이 : %d\n", age );

}



class Body : public Year

{

double ki;

public : 

Body( char * name="no", int age=0, double ki=0 );

void dispBody(); // 키 출력

void disp(); // 키 출력

};


Body::Body( char * name, int age, double ki ) : Year( name, age ) {

this->ki = ki;

}


void Body::dispBody() {

printf("나이 : %.lf\n",ki );

}


void Body::disp() {

printf("나이 : %.lf\n",ki );

}




void main()

{

Body hong("홍길동",40,175.5);

hong.dispName();

hong.dispYear();

hong.dispBody();

hong.disp();

hong.Name::disp();

hong.Year::disp();

hong.Body::disp();


}


*/




class Shape {

protected : 

int a, b; // 밑면 높이 or 반지름

double area; // 넓이

public : 

void disp(); // 출력

};


void Shape::disp() {

printf("넓이 : %.2lf\n", area );

}






class Rect : public Shape {

public : 

void input(); // 밑변 높이 입력

void calc(); // 넓이 계산

//Rect( int a, int b );

};


void Rect::input() {

puts("사각형의 넓이" );

printf( "밑변 : " );

scanf( "%d", &a );

printf( "높이 : " );

scanf( "%d", &b );

}

void Rect::calc()  {

area = a * b;

}




class Tri : public Rect {

public : 

void input(); // 반지름 입력

void calc(); // 넓이 계산

};


void Tri::input()

{

puts("삼각형의 넓이" );

printf( "밑변 : " );

scanf( "%d", &a );

printf( "높이 : " );

scanf( "%d", &b );

}

void Tri::calc()

{

area = a * b / 2.0;

}





class Circle : public Tri {

public : 

void input(); // 반지름 입력

void calc(); // 넓이 계산

};


void Circle::input()

{

puts( "원의 넓이" );

printf( "반지름 : " );

scanf( "%d", &a );

}

void Circle::calc()

{

area = a * a * 3.14;

}





void main() {

// Circle 클래스 객체로 모든 넓이를 출력

Circle c;


c.Rect::input();

c.Rect::calc();

c.Rect::disp();


printf("\n");


c.Tri::input();

c.Tri::calc();

c.Tri::disp();


printf("\n");

c.input();

c.calc();

c.disp();


printf("\n");


//c.input();

//c.calc();

//c.disp();


}

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

'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

130821.12일차

|

헤더




#include <stdio.h>

#include <stdlib.h>

#include <conio.h>

#include <string.h>

#include <iostream>

#include <iomanip>





메인




#include "130821.h"




/*


class Score

{


private : // 구조체는 기본이 public이다 class는 기본이 private

// 멤버 변수

char name[10];

int kor;

public : // 함수는 public

//멤버 함수 선언

void setName( char * n );

void setKor( int k ) ;

char * getName();

int getKor();


}; // 클래스 구현부



void Score::setName( char * n ) {

if ( strlen(n)+1 > 10) {

puts("네 글자까지만 입력하세요.");

strcpy(name," ");

} else { 

strcpy(name,n);

}

}



void Score::setKor( int k ) {

if ( k < 0 || k > 100 ) {

puts("0~100 사이만 입력하세요.");

kor = 0;

} else {

kor = k;

}

}


char * Score::getName() {

return name;

}


int Score::getKor() {

return kor;

}


void main() 

{

Score kim; // 스택에 할당

kim.setName("홍길동");

kim.setKor(50);

printf("이름 : %s\n", kim.getName() );

printf("국어 : %d\n", kim.getKor() );

//kim.getName();

//kim.getKor();


printf("\n");


Score lee;

lee.setName("홍길동만세"); // 네글자까지만 입력하세요

lee.setKor(-50); // 0~100 사이만 입력하세요.

printf("이름 : %s\n", lee.getName() );

printf("국어 : %d\n", lee.getKor() );

//lee.getName();

//lee.getKor();


printf("\n");


// 객체 동적할당


Score * ap = new Score;

ap->setName("이순신");

ap->setKor( 30 );

printf("이름 : %s\n", ap->getName() );

printf("국어 : %d\n", ap->getKor() );


delete ap;


// 객체 배열

//Score m[3] = { {"홍길동",30} , {"이순신",40} , {"김유신",50} } // 안됨

Score m[3];

m[0].setName("홍길동");

m[0].setKor( 30 );



}


*/




/* 생성자 constructor / 소멸자 destructor


자동호출 된다.



생성자 - 객채 생성시 - 객체 초기화에 사용

소멸자 - 객체 소멸시 - 메모리 반환에 사용


생성자/소멸자는 클래스 명과 동일하다

소멸자 앞에는 ~를 붙인다.

결과형이 없다. // return을 안함


생성자가 없으면 default constructor가 실행된다.

소멸자는 오버로드 할 수 없다.

반드시 public 선언이고 const 할 수 없다.

상속 할 수 없다.




*/



/*


// 선언부

class Person {

private:

char * name;

int age;


public:

//Person(); // 디폴트 생성자

Person(char * n, int a); // 디폴트 생성자

~Person(); // 디폴트 소멸자

void setName( char * n);

void setAge( int a );

char * getName();

int getAge();

};


Person::Person(char * n=" "  , int a=0) {

puts("생성자");

name = new char[strlen(n)+1];

strcpy(name,n);

age=a;

}


//Person::Person() {

// puts("디폴트 생성자");

// strcpy(name,"");

// age=0;

//}


Person::~Person() {

puts("디폴트 소멸자");

}



void Person::setName( char * n ){

strcpy(name,n);

}


void Person::setAge( int a ) {

age=a;

}


char * Person::getName() {

return name;

}


int Person::getAge() {

return age;

}




// 메인

void main()

{

Person kim; // 생성자 호출

//kim.setName("홍길동");  // 생성자는 이런짓 하지말자고 있는것

//kim.setAge(30);

printf("이름:%s\n",kim.getName());

printf("나이:%d\n",kim.getAge());


printf("\n");


Person lee("홍길동",30); 


printf("이름:%s\n",lee.getName());

printf("나이:%d\n",lee.getAge());


printf("\n");


Person park("김유신",50); 


printf("이름:%s\n",park.getName());

printf("나이:%d\n",park.getAge());


// park lee kim 순으로 반납됨.

// 3개 만들어서 소멸자도 3개 출력


printf("\n");


// 객체 동적 할당

Person * ap = new Person("대조영",50);

printf("이름:%s\n",ap->getName());

printf("나이:%d\n",ap->getAge());

// heap동적할당에 잡으면 소멸자가 없다.

// heap영역에 잡힌 데이터가 반납이 안됐다.

delete ap; // 동적할당은 꼭 반납


printf("\n");

// 객체 배열

Person m[3] = { Person("홍길동",30) , // 생성자를 호출함

Person("이순신",40) , 

Person("김유신",50) };


int i;

for (i=0 ; i<3 ; i++) {

printf("이름:%s\n",(m+i)->getName());

printf("나이:%d\n",(m+i)->getAge());

}

printf("\n");


// 객체 배열을 포인터로


Person * w[3] = { new Person("홍홍홍",60) , // 생성자를 호출함

 new Person("이이이",70) , 

 new Person("김김김",80) };

for (i=0 ; i<3 ; i++) {

printf("이름:%s\n",w[i]->getName());

printf("나이:%d\n",w[i]->getAge());

}

for (i=0 ; i<3 ; i++) {

delete w[i]; // 반납은 따로따로 해줘야함

}


}



*/




//생성자 소멸자 호출

//멤버함수나 생성자일때 매개변수는 변수*this로 주소를 받아준다.

//this를 쓰면 함수를 하나만 만들어서 사용하기 때문에 메모리 낭비를 줄여줌

//this를 안쓰면 쓰레기 값나온다.


/*


class Plus

{

private :

int a, b, res;


public : 

Plus( int a=0, int b=0 );

void disp();

~Plus();

} ;


Plus::Plus( int a , int b )

{

puts("생성자");

this->a = a;

this->b = b;

this->res = a+b;

}


Plus::~Plus()

{

puts("소멸자");


}



void Plus::disp()

{

printf("%d + %d = %d\n", this->a, this->b, this->res);


}



void sub();


void main()

{

puts("메인시작");


Plus m(5,2);

m.disp();


Plus w(3,7);

w.disp();



sub();


puts("메인 끝");

}



void sub(){


puts("sub 시작");

Plus z(10,20);

z.disp();


puts("sub 끝");

}


*/


// 연산자 멤버 함수 ( operator 함수 )



/*

// 선언부

class Oil

{

char name[12];

int price; 


public : 

Oil( char * name="no", int price=0 );

void set( char * name );

void set( int price );

void up( int price );

void down( int price );

void disp();

/// operator 함수

void operator  = ( char * name );

void operator  = ( int price );

void operator += ( int price );

void operator -= ( int price );

};







Oil::Oil( char * name , int price) {

strcpy(this->name,name);

this->price=price;

}


/// operator 함수

void Oil::set( char * name ) {

strcpy(this->name,name);

}

void Oil::set( int price ) {  // 오버로드

this->price=price;

}

void Oil::up( int price ) {

this->price+=price;

}

void Oil::down( int price ) {

this->price-=price;

}

void Oil::disp() {

printf("%s의 가격은 %d원 입니다.\n", name, price);

}


// class 함수


void Oil::operator = ( char * name ) {

strcpy(this->name, name);

}

void Oil::operator = ( int price ) {

this->price = price;

}


void Oil::operator += ( int price ) {

this->price += price;

}


void Oil::operator -= ( int price ) {

this->price -= price;

}



// 메인

void main()

{

Oil soil("휘발유",2000);

soil.disp();

soil = "경유"; // operator함수 사용

soil.disp();

soil = 1500;

soil.disp();

soil += 100;

soil.disp();

soil -= 50;

soil.disp();


printf("\n");


//Oil oil("휘발유",2000); // operator함수가 아님

//oil.disp();

//oil.set("경유");

//oil.disp();

//oil.set(1500);

//oil.disp();

//oil.up(100);

//oil.disp();

//oil.down(50);

//oil.disp();


}


*/



// 문자열 정리


/*

class String

{

char str[255];


public : 

String( char * str = "\0");

void disp();

String operator + ( char * str );

void operator = ( String & w ) ;

String operator + (String & w );

void operator += ( char * str );

};




String::String( char * str ) {

strcpy( this->str, str ); // ABC

}


void String::disp() {

printf("문자열 : %s\n", str );

}


String String::operator + ( char * str ) {

strcat(this->str,str); // DEF

return *this;

}


void String::operator = ( String & w ) {

strcpy(this->str,str); // DEF

}


String String::operator + (String & w ) {

strcat(this->str,w.str); // 주의

return *this; // GHI

}


void String::operator += ( char * str ) {

strcat(this->str,str); //JKL

}



void main() {

String m("ABC");

m.disp();


m = m + "DEF"; // ABCDEF

m.disp();


String z("GHI");

m = m + z;

m.disp();


m += "JKL";

m.disp();


}


*/


/*


class Score {

char * name;

int kor, eng, mat, tot; 

double avg;

public : 

Score( char * name, int kor, int eng, int mat);

~Score();

//void calc(); // 총점 평균 계산

char * getName();

int getKor();

int getEng();

int getMat();

//int getTot();

//double getAvg();

};


Score::Score( char * n="" , int kor=0 , int eng=0 , int mat=0) {

name = new char[strlen(n)+1];

strcpy(name,n);

this->kor=kor;

this->eng=eng;

this->mat=mat;

}


//void Score::calc( int tot, double avg ) {

// this->tot=kor+eng+mat;

// this->avg=(this->tot)/3.;

//

//}


char * Score::getName() {

return name;

}


int * Score::getKor() {

return kor;

}


int * Score::getEng() {

return eng;

}


int * Score::getMat() {

return mat;

}


//int * Score::getTot() {

// return tot;

//}

//

//double * Score::getAvg() {

// return avg;

//}


void main() {

// 객체 배열로 관리

// 출력 // 메인에서 출력

// 이름 국어 영어 수학 총점 평균

// 홍길동 00 00 00 00 00.00

// 김길동 00 00 00 00 00.00

// 이길동 00 00 00 00 00.00

// 박길동 00 00 00 00 00.00


Score * m[4] = { new Score("김태연",34,25,64) , // 생성자를 호출함

new Score("티파니",65,38,24) , 

new Score("최수영",45,62,85) , 

new Score("서주현",83,40,14) };

printf("이름\t국어\t영어\t수학\t총점\t평균\t");


for (int i=0 ; i<4 ; i++) {

printf("%s\t%d\t%d\t%d\t%d\t%.2lf\t",

m[i]->getName(),

m[i]->getKor(),

m[i]->getEng(),

m[i]->getMat() ); //,

//m[i]->getTot(),

//m[i]->getAvg() );

}

}


*/


class Score {

private:

char * name;

int kor;

int eng;

int mat;

int tot;

double avg;

public:

Score(char * n, int kor, int eng, int mat);

~Score();


void calc();

char * getName();

int getKor();

int getEng();

int getMat();

int getTot();

double getAvg();



};


Score::Score(char * n=" ", int kor=0, int eng=0, int mat=0) {

name = new char[strlen(n)+1];

strcpy(this->name,n);

this->kor=kor;

this->eng=eng;

this->mat=mat;

}

Score::~Score() {

delete name;

}



char * Score::getName() {

return this->name;

}


int Score::getKor() {

return this->kor;

}

int Score::getEng() {

return this->eng;

}

int Score::getMat() {

return this->mat;

}

void Score::calc() {

this->tot = this->kor + this->eng + this->mat;

this->avg = this->tot/3.;

}

int Score::getTot() {

return this->tot;

}

double Score::getAvg() {

return this->avg;

}




void main() {

// 객체 배열로 관리

// 출력 // 메인에서 출력

// 이름 국어 영어 수학 총점 평균

// 홍길동 00 00 00 00 00.00

// 김길동 00 00 00 00 00.00

// 이길동 00 00 00 00 00.00

// 박길동 00 00 00 00 00.00


Score * m[4] = { new Score("김태연",34,25,64) , // 생성자를 호출함

new Score("티파니",65,38,24) , 

new Score("최수영",45,62,85) , 

new Score("서주현",83,40,14) };

printf("이름\t국어\t영어\t수학\t총점\t평균\t\n");


for (int i=0 ; i<4 ; i++) {

m[i]->calc();

printf("%s\t%d\t%d\t%d\t%d\t%.2lf\t\n",

m[i]->getName(),

m[i]->getKor(),

m[i]->getEng(),

m[i]->getMat(), 

m[i]->getTot(),

m[i]->getAvg());

}


for (int i=0 ; i<4 ; i++) {

delete m[i];

}

}


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

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

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
130816.9일차  (0) 2013.08.19
Trackback 0 And Comment 0
prev | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | ··· | 10 | next

티스토리 툴바