C# (Csharp) 프로그래밍

가상함수


#include "stdafx.h"
#define DEBUG

class A{
    int i;
public:
	A(){
		i=0;
	}
	virtual void Print() { printf("%d\n",i);}
};

class B : public A {
	int i;
public:
	B(){
		i=1;
	}
	virtual void Print()  { printf("%d\n",i);}
};

class C : public B {
	int i;
public:
	C(){
		i=2;
	}
	virtual void Print() { printf("%d\n",i);}
};

void main()
{
	A* ap;
	B b;
	C c;
	ap=&b;
	ap->Print();
	ap=&c;
	ap->Print();

#ifdef DEBUG
	//cmd
	char e;
	scanf("%c",&e);
#endif
}

#include "stdafx.h"

#define DEBUG

class A{

int i;

public:

A(){

i=0;

}

virtual void Print() { printf("%d\n",i);}

};

class B : public A {

int i;

public:

B(){

i=1;

}

virtual void Print() { printf("%d\n",i);}

};

class C : public B {

int i;

public:

C(){

i=2;

}

virtual void Print() { printf("%d\n",i);}

};

void main()

{

A* ap;

B b;

C c;

ap=&b;

ap->Print();

ap=&c;

ap->Print();

#ifdef DEBUG

//cmd

char e;

scanf("%c",&e);

#endif

}

베이스 클래스이 포인터를 이용하여 하위 클래스의 멤버 함수를 호출하기 위해서는 멤버 함수가 가상이어야 한다. 즉, 하위 클래스에서 오버라이딩할 것 같은 함수는 베이스에서 모두 가상으로 선언한다.

복사생성자 operator


#include "stdafx.h"
#include <string.h>
#include <conio.h>

#define DEBUG

class CStr{
    char* str;
public:
	CStr(char *s=""){
		str = new char[strlen(s)+1];
		strcpy(str,s);
		printf("construction\n");
	}
	CStr(const CStr &s){
		str = new char[strlen(s.Get())+1];
		strcpy(str,s.Get());//const 객체는 const 멤버 함수만을 호출할 수 있다.
		printf("construction\n");
	}
	~CStr() {
		delete[] str;
		printf("destructor\n");
	}
	char* Get() const{
		return str;
	}
	void Print() {printf("%s\n", str);}

	CStr& operator=(CStr &s){
		delete[] str;
		str=new char[strlen(s.Get())+1];
		strcpy(str,s.Get());
		printf("=operator\r\n");
		return *this;
	}
};

void f(CStr s){
	s.Print();
}

void main()
{
	CStr s("hello"),t("world");
	CStr u=s;//3. 객체의 선언에 사용된 대입 연산자
	f(u);//1. 함수의 파라미터로 객체를 전달
	s=t;//*객체간의 대입문은 복사 생성자를 호출하지 않는다.
	//operator= 호출
	s.Print();

#ifdef DEBUG
	//cmd
	char c;
	scanf("%c",&c);
#endif
}

#include "stdafx.h"

#include <string.h>

#include <conio.h>

#define DEBUG

class CStr{

char* str;

public:

CStr(char *s=""){

str = new char[strlen(s)+1];

strcpy(str,s);

printf("construction\n");

}

CStr(const CStr &s){

str = new char[strlen(s.Get())+1];

strcpy(str,s.Get());//const 객체는 const 멤버 함수만을 호출할 수 있다.

printf("construction\n");

}

~CStr() {

delete[] str;

printf("destructor\n");

}

char* Get() const{

return str;

}

void Print() {printf("%s\n", str);}

CStr& operator=(CStr &s){

delete[] str;

str=new char[strlen(s.Get())+1];

strcpy(str,s.Get());

printf("=operator\r\n");

return *this;

}

};

void f(CStr s){

s.Print();

}

void main()

{

CStr s("hello"),t("world");

CStr u=s;//3. 객체의 선언에 사용된 대입 연산자

f(u);//1. 함수의 파라미터로 객체를 전달

s=t;//*객체간의 대입문은 복사 생성자를 호출하지 않는다.

//operator= 호출

s.Print();

#ifdef DEBUG

//cmd

char c;

scanf("%c",&c);

#endif

}

operator의 필요성


#include "stdafx.h"
#include <string.h>
#include <conio.h>

#define DEBUG

class CStr{
    char* str;
public:
	CStr(char *s=""){
		str = new char[strlen(s)+1];
		strcpy(str,s);
		printf("construction\n");
	}
	CStr(const CStr &s){
		str = new char[strlen(s.Get())+1];
		strcpy(str,s.Get());//const 객체는 const 멤버 함수만을 호출할 수 있다.
		printf("construction\n");
	}
	~CStr() {
		delete[] str;
		printf("destructor\n");
	}
	char* Get() const{
		return str;
	}

	void Print() {printf("%s\n", str);}
};

void f(CStr s){
	s.Print();
}

void main()
{
	CStr s("hello"),t("world");
	CStr u=s;//3. 객체의 선언에 사용된 대입 연산자
	f(u);//1. 함수의 파라미터로 객체를 전달
	s=t;//*객체간의 대입문은 복사 생성자를 호출하지 않는다.
	//그래로 복사(bitwise copy)//error
	s.Print();

#ifdef DEBUG
	//cmd
	char c;
	scanf("%c",&c);
#endif
}
 삭제

#include "stdafx.h"

#include <string.h>

#include <conio.h>

#define DEBUG

class CStr{

char* str;

public:

CStr(char *s=""){

str = new char[strlen(s)+1];

strcpy(str,s);

printf("construction\n");

}

CStr(const CStr &s){

str = new char[strlen(s.Get())+1];

strcpy(str,s.Get());//const 객체는 const 멤버 함수만을 호출할 수 있다.

printf("construction\n");

}

~CStr() {

delete[] str;

printf("destructor\n");

}

char* Get() const{

return str;

}

void Print() {printf("%s\n", str);}

};

void f(CStr s){

s.Print();

}

void main()

{

CStr s("hello"),t("world");

CStr u=s;//3. 객체의 선언에 사용된 대입 연산자

f(u);//1. 함수의 파라미터로 객체를 전달

s=t;//*객체간의 대입문은 복사 생성자를 호출하지 않는다.

//그래로 복사(bitwise copy)//error

s.Print();

#ifdef DEBUG

//cmd

char c;

scanf("%c",&c);

#endif

}

삭제

복사생성자


#include "stdafx.h"
#include <string.h>
#include <conio.h>

#define DEBUG

class CStr{
    char* str;
public:
	CStr(char *s=""){
		str = new char[strlen(s)+1];
		strcpy(str,s);
		printf("construction\n");
	}
	CStr(const CStr &s){
		str = new char[strlen(s.Get())+1];
		strcpy(str,s.Get());//const 객체는 const 멤버 함수만을 호출할 수 있다.
		printf("construction\n");
	}
	~CStr() {
		delete[] str;
		printf("destructor\n");
	}
	char* Get() const{
		return str;
	}

	void Print() {printf("%s\n", str);}
};

void f(CStr s){
	s.Print();
}


void main()
{
	CStr s("hello");
	f(s);

#ifdef DEBUG
	//cmd
	char c;
	scanf("%c",&c);
#endif
}

#include "stdafx.h"

#include <string.h>

#include <conio.h>

#define DEBUG

class CStr{

char* str;

public:

CStr(char *s=""){

str = new char[strlen(s)+1];

strcpy(str,s);

printf("construction\n");

}

CStr(const CStr &s){

str = new char[strlen(s.Get())+1];

strcpy(str,s.Get());//const 객체는 const 멤버 함수만을 호출할 수 있다.

printf("construction\n");

}

~CStr() {

delete[] str;

printf("destructor\n");

}

char* Get() const{

return str;

}

void Print() {printf("%s\n", str);}

};

void f(CStr s){

s.Print();

}

void main()

{

CStr s("hello");

f(s);

#ifdef DEBUG

//cmd

char c;

scanf("%c",&c);

#endif

}

복사 생성자가 호출되는 경우 1. 함수의 파라미터로 객체를 전달 2. 함수가 객체를 리턴 3. 객체의 선언에 사용된 대입 연산자 4. 임시 객체의 복사

복사생성자의 필요성 샘플


#include "stdafx.h"
#include <string.h>
#include <conio.h>

#define DEBUG

class CStr{
    char* str;
public:
	CStr(char *s=""){
		str = new char[strlen(s)+1];
		strcpy(str,s);
		printf("construction\n");
	}
	~CStr() {
		delete[] str;
		printf("destructor\n");
	}
	void Print(){
		printf("%s\n",str);
	}
};

//void f(CStr s)오류 //생성자에서 동적으로 메모리를 할당하는 
//객체를 파라메터로 전달할 때는 항상 포인터 혹은 레퍼런스를 전달한다.
void f(CStr& s)
{
	s.Print();
}

void main()
{
	CStr s("hello");
	f(s);

#ifdef DEBUG
	//cmd
	char c;
	scanf("%c",&c);
#endif
}

#include "stdafx.h"

#include <string.h>

#include <conio.h>

#define DEBUG

class CStr{

char* str;

public:

CStr(char *s=""){

str = new char[strlen(s)+1];

strcpy(str,s);

printf("construction\n");

}

~CStr() {

delete[] str;

printf("destructor\n");

}

void Print(){

printf("%s\n",str);

}

};

//void f(CStr s)오류 //생성자에서 동적으로 메모리를 할당하는

//객체를 파라메터로 전달할 때는 항상 포인터 혹은 레퍼런스를 전달한다.

void f(CStr& s)

{

s.Print();

}

void main()

{

CStr s("hello");

f(s);

#ifdef DEBUG

//cmd

char c;

scanf("%c",&c);

#endif

}

가상함수

복사생성자 operator

operator의 필요성

복사생성자

복사생성자의 필요성 샘플

Debug_New.h 사용예

#define TODO(msg) 사용

pragma message 빌드창에 표시

특별한 메크로

define DEBUG