뻔뻔한블로그

함수 오버로딩

매개변수는 다르지만 동일한 이름의 멤버 함수를 여러 개 작성할 수 있는 기능이다. 

1. 구현 방법

	void Add()
	{

	}	
    void Add(string s1, string s2)
	{
		...~~~
	}
	void Add(int a, int b)
	{
		...~~~
	}

함수 이름은 같지만 받는 매개변수가 다르다.

같은 이름의 함수를 호출하지만 상황에 따라 다른 결과를 얻어 낼 수 있다. 예를 들어 같은 기능이지만 매개변수 타입의 따른 다른 결과를 원할 때 사용하면 된다. 

연산자 오버 로딩

기존의 제공하고 있는 연산자를 재정의하여 원하는 방식으로 수정하여 사용할 수 있다. 전역 함수나 클래스로 재정의도 가능하다.

1. 구현 방법

	Student() { name = "ji"; }
	Student(string name) :name(name) {}

	Student operator + (const Student& other)
	{
		return Student(Student(name + " & " + other.name));
	}

operator를 사용하여 '+'의 연산자를 재정의 한다. 

	Student st1;
	Student st2("han");
	Student result = st1 + st2;

'+'은 기본적으로 더한다라는 정의하지만 내가 만든 Student의 객체를 '+'한다는 의미는 컴파일러는 알지 못한다. 하지만 위에서 정의한 '+'의 기능을 정의하였기에 아래와 같은 결과를 볼 수 있다. 이런 기능을 사용하므로 코드의 길이를 줄일 수 있는 장점이 있다.

2. 규칙

연산자 오버 로딩의 규칙들이 있다.

기존의 있는 연산자만 가능하다 (새로운 연산자를 만들어 낼 수는 없음)

멤버 연산자(.), 범위 지정 연산자(::), 전처리기 연결(##)등의 몇몇 연산자는 불가능하다.

피연산자의 개수 규칙 등 기본적인 연산자의 규칙 등 기본적인 연산자의 규칙을 따라야 한다. 

오버 로딩이 된 연산자 중 하나는 사용자 정의 자료형 이어야 한다.

클래스 상속

부모(베이스) 클래스 안에 있던 멤버 변수와 멤버 함수를 물려받아 새로운 클래스를 작성할 수 있게 된다. 객체지향 언어의 가장 큰 특징이며 장점이라고 생각된다.

1. 구현방법

class Person
{
	~~~~부모
}


class Student : Person 
{
	~~~~자식
}

Person은 부모 클래스 Student는 자식 클래스라 보면 자식 클래스 옆에  : 을 사용하여 Person의 자식이라는 것을 정의한다.

2. 예시

class Person
{

private:
	string name;

public:
	Person(string name) : name(name)
	{
	}
	string GetName()
	{
		return name;
	}

};

class Student : Person 
{
private:
	int studentID;
public:
	Student(int studentID, string name) : Person(name)
	{
		this->studentID = studentID;
	}

	void Show()
	{
		cout << "학생 번호 : " << studentID << '\n';
		cout << "학생 이름 : " << GetName() << '\n';
	}

};

int main()
{
	Student student(1,"han");
	student.Show();
	system("pause");
}

Student라는 객체를 새로 생성하면서 생성자를 통해 학생 번호와 이름을 부여하고 있다. Student는 name이라는 변수는 없지만 Person(name)을 통해 부모의 변수의 값을 넣을 수 있게 된다.

3. 다중 상속

class TempClass
{
public :
	void ShowTemp()
	{
		cout << "임시 부모 \n";
	}

};

class Student : Person, public TempClass
{
private:
	int studentID;
public:

~~~...

int main()
{
	Student student(1,"han");
	student.ShowTemp();
	system("pause");
}

C#은 안되지만, C++은 다중 상속이 가능하다. 

4. 장점

1) 코드 중복이 없어진다. 2) 함수 재활용이 가능해진다.

오버라이딩

상속받은 자식 클래스에서 부모 클래스의 함수를 사용하지 않고 자식 클래스의 함수로 재정의 해서 사용하는 것이다. 아래 예시를 보면 쉽게 이해가 될 것이다.

class Person
{

private:
	string name;

public:
	Person(string name) : name(name)
	{
	}
	string GetName()
	{
		return name;
	}

	void ShowName()
	{
		cout << "이름 :" << GetName() << '\n';
	}
};

class Student : Person, public TempClass
{
private:
	int studentID;
public:
	Student(int studentID, string name) : Person(name)
	{
		this->studentID = studentID;
	}

	void Show()
	{
		cout << "학생 번호 : " << studentID << '\n';
		cout << "학생 이름 : " << GetName() << '\n';
	}
	void ShowName()
	{
		cout << "학생 이름 :" << GetName() << '\n';
	}
};



int main()
{
	Student student(1,"han");
	student.ShowName();
	system("pause");
}

부모인 Person클래스도 ShowNmae() 함수가 있고, 자식인 Student도 ShowName() 함수가 있다. 이 과정을 오버 라이딩이며 부모 함수를 무시하고 자식 함수를 실행하게 된다.

추가적으로

1. 자식(파생) 클래스의 객체를 생성하면, 부모(베이스) 클래스의 생성자를 호출한 뒤, 자식 클래스의 생성자가 호출된다.

2. 소멸자는 반대로 자식 클래스가 먼저 호출되고 그 후에 부모 클래스의 소멸자가 호출된다. 

생성자

객체를 생성함과 동시에 멤버 변수를 초기화할 수 있다. 인스턴스화될 때 자동으로 호출되며,  클래스의 멤버 변수를 적절한 기본값 또는 사용자가 정의한 값을 갖는 인스턴스가 생성되는 것이다. 

1. 구현방법

class Student
{
private:
	string name;
	int englishScore;
	int mathScore;

public:

	Student(string n ,int e, int m)
	{
		name = n;
		englishScore = e;
		mathScore = m;
	}

};

일반 메서드를 작성하는 방법과 같다. 이름은 클래스 이름과 같게 설정해주면 된다.(반환 값은 없음) Student인 새로운 객체를 만들 때 name, englishscore, mathscore의 각각 해당하는 값을 할당해주면서 이 객체는 초기화된다.

2. 사용방법

1) 클래스 이름과 같아야함 2) 반환 값이없어야함

int main(void)
{
	Student a = Student("Mr.Han",100,98); // Student 생성!

}

 이렇게 해주면 끝!

	Student* st1 = new Student("han" , 100, 98);
	st1->NumberUp();

이런식으로 동적으로 생성할때도 생성자는 동작한다.

3. 디폴트 생성자

public:

	//Student(string n ,int e, int m) //생성자 주석.
	//{
	//	name = n;
	//	englishScore = e;
	//	mathScore = m;
	//}
};

int main(void)
{
	Student a = Student(); //매개변수 X

}

작성한 생성자가 없을때는 매가변수가 없는 기본 생성자로 인식한다. 멤버 변수들은 '0'혹은 'NULL'인 값으로 설정된다.

4. 복사생성자

매개변수의 값을 넘겨주는 일반 생성자와 다르게 객체를 넘겨 복사를 하도록 하는 생성자이다.

int number = 0;

class Student
{


private:
	string name;
	int englishScore;
	int mathScore;
	int num;

public:

	Student(string n, int e, int m)
	{
		name = n;
		englishScore = e;
		mathScore = m;
	}
	Student(const Student &st)
	{
		name = st.name;
		englishScore = st.englishScore;
		mathScore = st.mathScore;
	}
	void NumberUp()
	{
		number++;
		num = number;
	}

	void Show()
	{
		cout << "번호 " << num << "이름 " << name << "영어 " << englishScore << "수학 " << mathScore << '\n';

	}
};

int main()
{
	Student* st1 = new Student("han" , 100, 98);
	st1->NumberUp();
	Student st2(*st1);
	st2.NumberUp();
	st1->Show();
	st2.Show();

	system("pause");
}

st1을 만들고 st2를 만들때 생성자에 *st1을 넘김으로 써 st1을 그대로 복사한다. 각 Student객체는 NumberUp()으로 int number를 한개씩 증가 시켜 각각 num의 값을 다르게 넣도록 했다. 

소멸자

객체의 수명이 끝났다고 판단되면 이 객체를 제거하기 위한 목적으로 사용된다. 객체의 수명이 끝났을 때 자동으로 컴파일러가 소멸자 함수를 호출한다. 클래스명 앞에 '~'기호를 사용하여 작성한다. 

1. 구현방법

	~Student()
	{
		cout << "객체 소멸 \n";
	}

int main()
{
	Student* st1 = new Student("han" , 100, 98);
	st1->NumberUp();
	Student st2(*st1);
	st2.NumberUp();
	st1->Show();
	st2.Show();
	
	delete st1;
	system("pause");
}

st1은 선언한 지역이 끝날 때 메모리를 해제하기 전에 소멸자를 먼저 수행하지만, 동적으로 생성한 st2같은 경우는 delete키워드를 이용해 메모리를 해제요청하고 소멸자를 먼저 수행하도록 해야한다.

C++ 역시 클래스 멤버 선언 시 접근 제한자를 지정할 수 있다.

접근 제한자는 왜 필요할까?

객체지향 프로 래밍은 특히 이 접근 제한자를 잘 사용할 필요가 있다. 객체지향 프로그래밍은 한 완제품을 생상하는 공장의 기계들과 같다고 생각하면 좋을 것 같다. 예를 들어 자동차 한 대를 만들어 내기 위해서는 엔진, 부품 등등 여러 가지 제작, 결합 과정을 거치게 된다. 이 공장 기계들은 서로의 어떻게 부품을 만들어 내는지, 전혀 알 필요가 없다. 공장 기계들은 설계자가 시킨 작업만 진행하면 된다. 서로의 작업들의 내용을 공유하지 않기 위해 필요한 것이 정보은닉이다.

프로그램도 프로그래머가 설계한 클래스, 함수를 통해 자기 자신의 작업만 진행하면 된다. 이 접근 제한자는 프로그램을 보통 한명이 만들 때보다 여러 프로그래머가 동시에 작업을 할 때 특히 확실히 필요하게 된다.

#include <iostream>
#include <string>

using namespace std;

class Student
{
private:
	string name;
	int englishScore;
	int mathScore;
	int getSum()
	{
		return englishScore + mathScore;
	}
public:
	Student(string n ,int e, int m)
	{
		name = n;
		englishScore = e;
		mathScore = m;
	}
	void show() { cout << name << " : [합계 " << getSum() << "점]\n"; }

};

int main(void)
{
	Student a = Student("Mr.Han",100,98);
	a.show();

	system("pause");
}

배열과 포인터는 동일하다고 보면된다. 배열을 선언하면 그 이름자체가 포인터 변수가 되는 것이다.

a자체가 선언한 배열의 주소를 가지고 있는 것이다. 

문자열의 개념

문자열은 문자들의 배열이다. 끝을 알리는 목적으로 컴퓨터 메모리 구조상 마지막에 널값을 포함한다. 

문자열 형태로 포인터를 사용하면 포인터에 특정한 문자열의 주소를 넣게된다. 

"Hello World"문자열을 읽기 전용으로 메모리 공간에 넣은 뒤 그 위치를 처리한다. 

배열은 포인터와 치환되기 때문에 이런식으로 각각 char한 문자씩 출력이 가능하다. 

간단한 txt파일에 문자 입력하기

fopen() 함수의 원형 

FILE * fopen( const char *, const char * );

첫번째 인자 : 처리할 파일 명 

두번째 인자 : 파일 처리 종류 지정 (모드) 

r = 읽기 모드 / 파일이 없을 경우 에러 발생 

w = 쓰기 모드 / 파일이 없을 경우 새로 만들고, 파일이 존재하면 내용을 삭제하고 처음부터 기록 

a = 추가 쓰기 모드 / 파일이 없을 경우 새로 만들고, 파일이 존재하면 뒤에부터 이어서 기록 

fopen으로 파일을 열었다면 fclose를 사용하고 닫아 주도록 한다.

이렇게 실행하면 해당 프로젝트 폴더에 "temp"파일이 생성된것을 볼 수 있다.

그 안에는 "Hello World"가 입력되어있다.

1. 파일 읽고 쓰기.

input.txt 파일을 만든다.

이제 이 input.txt파일을 한줄 씩 읽고 하나씩 출력하는 프로그램을 만들기 위한 코드를 작성한다. 

Student라는 데이터를 입력받을 구조체 모델을 만든다.

구조체 포인터를 이용해 크기를 동적으로 할당한다. n은 총 학생수.

 빌드 후 확인한다.

1. 메모리 해제, 파일 닫기

sum에 다가 학생들의 점수를 모두 더하고 출력하도록 했다.

아스키 코드

아스키코드는 0~127중의 1바이트로 구성된다.

캐릭터형 자체에 숫자를 넣어서 처리할 수 있다. 

char 형으로 48을 받으면 아스키코드로 0을 나타내고 있는것을 알 수있다. char각각 매칭된다는것을 알 수 있다. 컴퓨터는 실제로 받아 들일때는 문자가아닌 숫자로 받고 있다는것이다.

Enum.Parse메서드는 문자열 enum인스턴스로 변환한다. 이 메서드는 enum형식과 멤버 이름을 담은 문자열을 받는다.

이런 enum이 있을 때 

"dog"라는 string으로 Enum.Parse를 사용하여 Animal의 enum을 받아올 수 있다. 

스태틱 함수 Parse(Type, String)을 사용하면 enum을 받아 올 수있다.

반환 값이 object이기에 캐스팅하면 원하는 타입으로 값을 얻어 올 수 있다. 

enum으로 선언되어있지 않은 값을 부르면 에러를 뱉는다.

빈 문자열

빈 문자열은 길이가 0인 문자열이다. 문자열을 초기화 하거나 값을 비워줄때 빈 문자열로 만든다. 이 빈 문자열을 만드는 방법들이 몇가지 있다.  

1. 리터럴을 이용

2. 정적 string.Empty필드를 이용

빈 문자열을 만들었으니 실제로 값이 비워져있는지 체크해보자

널 문자열

string은 참조 형식이므로null처리가 가능하다.

널처리된 sEmpty를 체크해보면

순서대로 true, false, NullReferenceException

전처리기 지시자

코드의 특정영역에 대한 추가적인 정보를 컴파일러에게 제공한다. 가장 흔히쓰이는 전처리기 지시자는 조건부 컴파일 지시자들이다. 

 if debug와 endif안에 있는 코드가 실행된다. 당연히 맨위 #define을 뺀다면 실행되지 않는다.

적용방법 :

1. 소스코드(클래스별로) 맨위에 #define을 선언한다.

2. 프로젝트 조건부 컴파일 기호에 define으로 사용할 기호를 넣으면 된다. 

단점

1. 디버깅이 힘들다.

=> 컴파일러 전단계에서 동작하므로 경고나 에러메세지 없이 코드의 흐름을 보기에 불편하다.

장점(언제쓰나)

1. 한 프로젝트로 다른 빌드버전 대응이 가능하다. 

바인딩이란?

형식이나 멤버, 연산을 구체적으로 결정하는 과정을 말한다. 변수를 예로 들면, 변수를 구성하는 식별자, 자료형 속성, 하나 이상의 주소, 자료 값에 구체적인 값으로 확정하는 것을 말한다. 이런 바인딩을 하는 시점에 따라 동적 바인딩, 정적 바인딩으로 나뉜다.

동적 바인딩

실행 시점에 진행되는 바인딩이다. 동적 바인딩은 컴파일 시점에서 어떤 함수나 멤버, 연산이 존재한다는 점을 프로그래머 자신을 알고 있지만 컴파일러는 알지 못하는 경우에 유용하다.

dynamic 키워드를 이용해 선언한다. 프로그래머는 d의 Quack()라는 함수가 있다고 가정하고 코드를 작성한다. 이렇게 하면 적으로 d와 Quack()은 바인딩된다.

정적 바인딩

 먼저 컴파일러는 p의 GetObj() 이름의 매개변수 없는 메서드를 찾는다. 그런 메서드가 없으면 컴파일러는 선택적 매개변수를 받는 메서드, 그다음에는 Progoram의 기반 클래스에 있는 메서드 여기에도 없으면 확장 메서드까지 찾는다. 없으면 컴파일 오류를 뱉는다. 정적 바인딩은 컴파일러가 바인딩을 과정을 수행하며 이미 선언되어 컴파일러가 확실하게 파악된 형식만 가능하게 되는 것이다. 

암묵적/명시적 널 가능 변환

T에서 T?로의 변환은 암묵적이고 T?에서 T로의 변환은 명시적이다.

명시적 캐스팅은 null가능 객체의 value속성을 조회하는 것에 직접 대응된다. 따라서 만일 HashValue가 거짓이면 에러가 발생한다. 

널 가능 값의 박싱과 언박싱

T?가 박싱된 경우, 힙에 있는 박싱된 값은 T?가 아니라 T를 담는다. 이러한 최적화가 가능한 것은, 박싱된 값은 이미 널을 표현할 수 있는 참조 형식이기 때문이다.

c#은 널 가능 형식을 as연산자로 언박싱하는 연산도 허용한다. (캐스팅 실패 시 null)

순차열 합성

요소들의 계산은 최대로 지연되다가, MoveNext() 호출해서 비로소 계산된다. 

Nullable구조체

컴파일러는 T를 가벼운 불변이 구조체인  System.Nullable<T>로 바꾸어 컴파일한다. 이 구조체에는 두가지 필드가 존재한다. Value와 HashValue라는 두 필드만 있다. 

아시다시피 C#에서 정수,구조체 등은 Value타입들은 null을 가질 수 없다. 하지만 이런 값타입도 값이 할당되지 않은 상태를 표현하고자 하려할때 Nullable구조체를 사용한다.

컴파일러는 위쪽 코드를 아래와 같이 바꾸어서 컴파일한다.

HashValue가 거짓인 널 가능 객체의 value를 조회하려 하면 InvalidOperationException이 발생한다. GetValueOrDefault()메서드 HashValue가 참이 면 value를 돌려주고 그렇지 않으면 new T()또는 지정된 커스텀 기본값을 돌려준다.

(T?의 기본값은 NULL)

반복자

foreach문은 열거자의 값들을 사용하는 소비자라면, iterator는 열거자의 생산자의 해당한다.

다음은 피보나치 수열의 수들을 돌려주는 반복자 메서드를 이용하여 반복자에 대해서 살펴보자

yield return 문은 "이 열거자에 원하셨던 다음 요소가 여기 있으니 받으세요"라고 말하는것과 같다.

함수가 실행된 후 내부상태가 유지 되지않는 return과 다르게 yield return은 내부 상태를 유지하며 다음에 호출차가 다시 열거를 수행하면 열거자는 다음 요소를 돌려주게 된다. 

반복자 의미론

반복자는 하나 이상의 yield문이 있는 메서드나 속성, 인덱서이다. 그렇기 때문에 IEnumerable열거 가능 인터페이스와 IEnumerator열거자 인터페이스와 호환되어야 한다. 

열거자와 반복자

값들의 순차열으 반복하는 읽기 전용 커서이다. 구체적으로

System.Collections.IEnumerator

System.Collections.Generic.IEnumerator<T>

위 두가지 인터페이스 중 하나를 구현하는 객체이다. 

Foreach문은 열거 가능객체를 반복한다.

열거 가능 객체는 순차열의 논리적 표현이다. 다음 두 조건 중 하나를 만족하는 객체는 열거 가능객체로 간주된다.

1. IEnumerator와 IEnumerable<T>를 구현한다.

2. 열거자를 돌려주는, GetEnumerator라는 메서드가 있다.

foreach문으로 훑는 예이다.

foreach없이 저수준으로 읽는 방법이다. 

열거자가 IDisposable를 구현하는 경우, foreach문은 using문으로도 작용한다. 즉, 반복이 끝나면 열거자 객체가 암묵적으로 처분된다.

Using문

클래스 중에는 파일 핸들이나그래픽 핸들, 데이터베이스 연결 같은 비관리 자원들을 캡슐화하는 것이 많다. 그런 자원들을 정리하기 위한, System.IDisposable인터페이스의 Dispose라는 메서드가 있다.

이번 포스트에 정리할 using은 콘솔창 맨위에 사용하는 지시문이 아니라 문장 형태의 using문이다.

using문을 사용하여 해당 리소스 범위를 벗어나게 되면 자동으로 리소스를 해제하여 관리하도록 하는 것이다.

이렇게 using문의 { }괄호를 벗어날때 Dispose가 된다.

다른 방법 try블록과 finally블록에서 Dispose를 호출한다.

Try문

try문은 오류 처리 또는 마무리코드를 위한 코드 블록을 지정한다. try블록 다음에 catch블록이나 finally블록이 올 수 있다. try블록 안에서 오류가 발생하면 catch블록이 실행한다. 

마무리 작업을 수행하기 위한 finally블록은 실행이 try블록을 벗어나면, 또는 catch블록이 존재하고 실제로 실행된 경우에는 catch문블록을 벗어나면 실행된다. 즉, finally블록은 오류가 발생하든 발생하지 않든 항상 실행된다.

어떻게 사용될지 예제를 보자.

위 예제를 실행하면 다음과 같은 오류를 뱉는다.

프로그램은 강제종료된다. 위와 같은 에러는 catch로 처리해 줄 수 있다.

실행결과 =>

실행순서는 이렇게 된다.

1. 함수에서 예외가 발생

2. catch블록으로 이동

3. catch블록의 실행이 성공적이면 try다음 문장으로 이동 (finally블록이 있다면 그것이 먼저 실행) 그렇지 않다면 실행은 함수를 호출한 곳으로 돌아간다(finally블록이 있다면 그것이 먼저 실행) 그런다음 같은 처리가 반복.

Catch 절

블록을 잡고자 하는 예외 형식을 괄호 쌍 안에 지정한다. 

그러한 예외 형식은 반드시 System.Exception클래스이거나 System.Exception의 파생 클래스이어야 한다.

finally 블록

finally블록은 항상 실행된다. 예외가 던져지든 아니든, 그리고 try블록이 끝까지 실행되든 아니든 이 블록은 항상 실행된다. 그래서 흔히 마무리 코드에서 쓰인다.

제네릭 형식의 파생

제네릭 형식도 제네릭이 아닌 클래스처럼 파생할 수 있다. 제네릭 클래스를 기반으로 삼아서 파생 클래스를 정의할 떄, 다음처럼 기반 클래스의 형식 매개변수를 옆린 채로 남겨두는 것이 가능함.

물론 이런식으로 구체적인 형식으로 매개변수를 제한 할 수도 있다.

또한 파생 형식에서 새로운 형식 매개변수를 도입할 수도 있다.

이렇게 사용하면 된다.

자신을 참조하는 제네릭 형식

파생 형식이 기반 형식의 형식 매개변수를 닫을 때, 파생 형식 자신을 형식 인수로 지정하는 것이 가능하다.

밑에 처럼 사용하면 되겠쥬?

형식 매개변수에 제약조건을 지정함으로써, 형식 매개변수에 대입할 수 있는 형식 인수들을 좀 더 제한하는 것이 가능하다.

4. 구조체 제약 조건

반드시 T가 값 형식(널 기능이 아닌)이어야 함을 뜻한다. 구조체 제약 조건의 좋은 예는 System.Nullable<T>구조체이다. 

2. 매개변수 없는 생성자 제약 조건

T에 반드시 매개변수 없는 공용 생성자가 있어야한다. 이를 만족하는 T에 대해서는 new()를 호출할 수 있다.

2. 적나라한 형식 제약 조건

형식 매개변수가 다른 형식 매개변수와 같은 형식이거나 그 파생 형식이어야 함을 뜻한다. 

형식 매개변수에 제약조건을 지정함으로써, 형식 매개변수에 대입할 수 있는 형식 인수들을 좀 더 제한하는 것이 가능하다. 

1. 참조 형식 제약 조건

사용 형태

제약조건은 참조 형식으로 설정했기 때문에 int는 에러를 발생한다.

2. 인터페이스 제약 조건

매개변수가 반드시 주어진 인터페이스를 구현해야 한다. 이러한 제약 조건들을 만족하는 형식 매개변수의 인스턴스는 해당 클래스나 인터페이스로 암묵적으로 변환된다. 

CompareTo메서드는 만일 this가 other보다 크면 양수를 돌려준다. 

어떤 형식도 인수로 받을 수 있다. 

3. 기반 클래스 제약 조건

형식 매개변수가 반드시 주어진 클래스 또는 그 클래스의 파생 클래스이어야 한다. 

제네릭

여러 형식들에서 재사용할 수 있는 코드를 작성하기 위한 메커니즘이 두 가지 있는, 하나는 상속이고 또 하나는 제네릭이다. 이 둘은 개별적인 메커니즘으로 상속은 기반 형식을 이용해서 재사용성을 표현하는 반면, 제네릭은 '자리표'에 해당하는 형식들은 담은 '템플릿'을 통해서 재사용성을 표현한다. 상속과 비교할 때, 제네릭을 사용하면 형식 안전성이 증가하고 캐스팅과 박싱이 줄어든다.  

제네릭 형식

형식 매개변수(type parameter)들을 선언한다. 형식 매개변수는 제네릭 형식이 실제로 쓰일 때 해당 코드가 제공한 실제 형식들이 대신할 자리를 표시하는 '자리표에'해당한다. 말이 어렵지 어떻게 사용하는지 보면 쉽게 이해할 수 있다.

간단하게 스택을 제네릭 형식으로 만든 예제이다. 이렇게 만드면 타입을 상관없이 스택에 담을 수 있게 된다. 

적용방법

이렇게 타입별로 클래스를 인스턴싱한 후 원하는 타입으로 사용할 수 있다. 이렇게 하면 위에서 나온 재사용이 가능해진 것이다. 

Object형식으로 만들면?

모든 타입을 포함하는 상위 클래스인 Object형식으로 스택을 만들면 가능하지만 이 제네릭과는 조금 다르다. object로 담을 수 있기 때문에

이런 식으로 여러 타입의 값들을 같은 배열에 담을 수 있다.(이렇게 사용하지는 않을 것 같음) 하지만 이것 자체가 박싱이며, 값들을 꺼낼 때도 하향 캐스팅이 필요하다. 박싱과 하향 캐스팅 둘 다 컴파일 시점에서 형식 점검이 일어나지 않기 때문에 실수할 가능성이 높다. 

지금은 아무 에러가 없지만 프로그램을 실행하면 컴파일 에러가 난다.

제네릭 스택은 인스턴스를 만들때 한번 설정한 타입으로 컴파일 시점에서 점검이 이루어지기 때문에 안전하게 사용이 가능한 것이다.

C#의 모든 형식은 실행 시점에서 System.Type의 인스턴스로 표현이 된다. 두 가지 방법으로 Type객체를 얻을 수 있다.

1. 인스턴스에 대해 GetType을 호출한다.

2. 형식 이름에 대해 Typeof연산자를 호출한다.

이 두가지의 큰 차이점은 GetType은 실행 시점에서 평가되는 반면에 typeof는 컴파일 시점에서 정적으로 평가된다.(제네릭 형식은 JIT(just-in-time compilation)컴파일러가 결정한다.)

1. GetType 

GetType을 실행해 보면 현재 인스턴스의 타입을 가져오고 있다. (자칫 클래스 이름을 가져온다고 생각할 수 있지만 타입이다 타입)

그러면 아래 실행결과는 어떤값을 보내줄까?

int형인 x의 타입이니 Int32를 보내준다.

Name을 사용하면 타입을 string값으로 받을 수 있다. 

1. typeof

형식에 대한 System.Type개체를 얻는데 사용된다. 

이렇게 타입형식을 참조할 수 있다.

이 두개의 차이점은?

이 두개의 실행결과를 예상해 보자. 정답은 위에서부터 각각 true, false, true, true, false다.

첫 번째는 타입을 비교하고 두 번째는 인스턴스를 비교하고 있다. child로 같은 타입이기 때문에 true이다.

두 번째는 Object.Equals를 이용해 인스턴스가 같은지를 비교하고 있다. new를 이용해 새로운 생성자 인스턴스를 리턴해주고 있기 때문에 c와 c2는 같지 않다. 

세 번째는 c와 c2모두 같은 타입이고 typeof은 타입을 반환하기 때문에 '==' 비교는 true를 출력하고 다섯 번째는 다른 타입과 비교를 하고 있어 false를 출력한다.

Object형식

Object형식은 모든 형식의 궁극적인 기반 클래스이다. 그 어떤 형식도 Object로 상향 캐스팅할 수 있다. 범용적으로 쓰이는 Stack구조를 살펴보자

        class Stack
        {
            public int Position;
            object[] array = new object[10];
            public void Push(object o)
            {
                array[Position++] = o;
            }
            public object Pop()
            {
                return array[Position--];
            }

        }

        static void Main(string[] args)
        {
            Stack stack = new Stack();
            stack.Push("Apple");
            string answer = (string)stack.Pop(); //하향 캐스팅
        }

그 어떤 형식의 인스턴스라도 push와 pop이 가능하다. 하지만 Object형식이기 때문에 Pop을 할 때는 명시적 캐스팅이 필요하다. 또, object는 하나의 클래스이며, 따라서 참조 형식이다. 그렇긴 하지만 int 같은 값 형식과 object사이의 캐스팅도 가능하다. c#의 이러한 특징을 형식 통합이라고 부른다.  

Object(참조) 형식도 int(값) 형식으로 변환이 가능하다.

박싱과 언박싱

위에서 살짝 언급한 내용으로 값 형식 인스턴스를 참조 형식 인스턴스로 변환하는 것을 박싱이다. 그럼 그 반대는? 언박싱이겠지라고 생각하는데 맞기는 하는데 한 가지 조건이 있다. 바로, 박싱 과정을 거친 객체를 되돌리는 것이 언박싱이다.

간단한 예제로 살펴보자

1.박싱

int x = 10;
object obj = x; //int 박싱

1.언박싱

int x = 10;
object obj = x; //int 박싱

int y = (int)obj; //int 언박싱

박싱은 그냥 하면 되고, 언박싱은 명시적 캐스팅이 필요하다. 이렇게 쉽게 참조 타입과 값 타입 사이에서 형식 변환을 쉽게 할 수 있다는 것은 매우 편리하다. 모든 함수와 자료구조 타입을 objct형식으로 만들어놓으면 캐스팅만 잘 사용한다면 코드 중복 없이 짧고 쉽게 설계가 가능할 것 같아 보인다. (이 세상에서 분명 공짜는 없다. 박싱과 언박싱에서는 단점이 있다. 다음에 설명 )

하지만, 기억해야 할 것은 objct는 참조 형식이고, int는 값 형식이다. 

박싱과 언박싱의 복사 의미론

박싱(값 -> 참조)은 값 형식 인스턴스를 새 객체로 복사하고, 언박싱(참조 -> 값)은 객체의 내용을 다시 값 형식 인스턴스로 복사한다. 말로 풀었을 때 무슨 소리인지 모르겠다. 이 과정은 어떤 과정인지 한 가지 예를 보고 살펴보자.

int i = 5;
object boxed = i;
i = 3;
Console.WriteLine(boxed);
Console.WriteLine(i);
Console.WriteLine(boxed);

먼저 출력 결과를 먼저 알려주면 위에서부터 5,3,5이다. 답을 맞혔다면 저 말을 이해가 된 것이다.  boxed와 i는 서로 다른 인스턴스 즉, "i는 boxed라는 새로운 인스턴스를 만들고 자신의 값을 복사했다."라는 말이다. 그래서 i의 값을 바꿔도 boxed의 값은 변경되지 않는다.

생성자와 상속

자식 클래스에서 부모클래스로 접근은 가능하지만 자식클래스에서 부모클래스의 생성자는 자동으로 상속되지 않는다.

    class Parent
    {
        public int X;
        public Parent() { }
        public Parent(int X)
        {
            this.X = X;
        }
    }
    class Child : Parent
    {

    }
    class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child(123); //컴파일에러
            Console.WriteLine(child.X);
        }
    }

자식클래스는 자신이 노출하고자 하는 생성자들을 반드시 '다시 정의' 해야한다.

    class Parent
    {
        public int X;
        public Parent() { }
        public Parent(int X)
        {
            this.X = X;
        }
    }
    class Child : Parent
    {
        public Child(int X) : base(X) { } //base 키워드를 사용하여 상속
    }
    class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child(123);
            Console.WriteLine(child.X);
        }
    }

만약 base키워드를 쓰지 않고 매개변수가 없는 생성자를 호출하면 부모클래스의 매개변수가 없는 생성자가 실행된다.

    class Parent
    {
        public int X;
        public Parent() { }
        public Parent(int X)
        {
            this.X = X;
        }
    }
    class Child : Parent
    {
        public int y;
    }
    class Program
    {
        static void Main(string[] args)
        {
            Child child = new Child();
            Console.WriteLine(child.X);
        }
    }

부모클래스에 접근 가능한 기본생성자가 하나도 없으면 자식클래스는 생성자에서 반드시 base클래스를 사용해야한다.

상속된 멤버 숨기기

클래스 상속을 하다보면, 부모클래스와 자식클래스에 동일한 멤버가 존재할 수 있다. (근데 되도록 이름을 다르게 지정하는게 좋다고 판단된다. 아무래도 헷갈릴수 있기 때문에)

        public class A
        {
            public int Counter = 1;
        }

        public class B : A
        {
            public int Counter = 2;
        }

똑똑한 비쥬얼스튜디오는 'new' 키워드를 이용하라고 제시한다. 

여기서 사용하는 'new'는 new연산자와 다르다.

new 키워드를 쓰나 안쓰나 똑같이 b.Counter는 b의 Counter = 2를 출력한다. 'new' 단지 컴파일러가 멤버 숨기기에 관한 경고를 내지 않게 만들고, 다른 프로그래머들에게 의도적인 것임을 알려주는 수단이라고 할 수 있다.

new와 override

        public class BaseClass
        {
            public virtual void Foo()
            {
                Console.WriteLine("BaseClass");
            }
        }

        public class Overrider : BaseClass
        {
            public override void Foo()
            {
                Console.WriteLine("Overrider.Foo");
            }
        }

        public class Hider : BaseClass
        {
            public new void Foo()
            {
                Console.WriteLine("Hider.Foo");
            }
        }
        static void Main(string[] args)
        {
            Overrider over = new Overrider();
            BaseClass b1 = over; //상향캐스팅
            over.Foo(); // Overrider.Foo
            b1.Foo();   // Overrider.Foo

            Hider h = new Hider();
            BaseClass b2 = h;
            h.Foo(); //Hider.Foo
            b2.Foo(); //Hider.Foo
        }

출력

부모클래스와 자식클래스의 함수명이 같게되면 'new'수정를 쓴 함수를 숨겨준다. 

캐스팅

상향캐스팅

    public class Asset
    {

    }
    public class Stock : Asset
    {

    }

    class Program
    {
        static void Main(string[] args)
        {
            Stock stock = new Stock();
            Asset asset = stock;
            
        }
    }

 상향 캐스팅 연산은 파생 클래스 참조로부터 기반 클래스 참조를 생성한다.

stock 와 asset가 가리키는 객체는 같다. (stock == asset는 true) 

    public class Foo
    {
        public static Foo Instance = new Foo();
        public static int X = 3;
        Foo() { Console.WriteLine(X); }
    }
    public class Asset
    {
        public int nInt;
    }
    public class Stock : Asset
    {
        public float fFloat;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Stock stock = new Stock();
            Asset asset = stock; //상향 캐스팅
            Console.WriteLine(asset.fFloat); //컴파일 오류

        }
    }

stock형식의 객체를 가리키긴 하지만 변수 자체의 형식은 Asset이기 때문에 fFloat변수접근이 불가능하다.

하향캐스팅

하향캐스팅 역시 변하는 것은 참조 뿐이다. 하향은 실행시점에서 실패 할 수도 있기 때문에 명시적으로 캐스팅이 필요하다.

 public class Foo
    {
        public static Foo Instance = new Foo();
        public static int X = 3;
        Foo() { Console.WriteLine(X); }
    }
    public class Asset
    {
        public int nInt;
    }
    public class Stock : Asset
    {
        public float fFloat;
    }

    class Program
    {
        static void Main(string[] args)
        {
            Stock stock = new Stock();
            Asset asset = stock; //상향 캐스팅

            Stock a = (Stock)asset; //하향 캐스팅

            Console.WriteLine(a.fFloat); 
            Console.WriteLine(a.nInt);

            Console.WriteLine(asset == stock); // true
            Console.WriteLine(asset == a); // true
            Console.WriteLine(a == stock); // true



        }
    }

as 연산자

as 연산자도 하향 캐스팅을 수행한다. 위와 다른점은 실패할 경우 null로 평가된다.

    class Program
    {
        static void Main(string[] args)
        {
            Asset a = new Asset();
            Stock s1 = (Stock)a;
            Stock s2 = a as Stock; // 예외를 발생하지 않음
        }
    }