다다

윈폼이라는 것에 대해서 알아봐야 할것이다.

MFC를 해본 나로서는 윈폼과 그에 대한 이벤트는 그렇게 까지 난해하게 다가오지는 않았다.

실제 MFC의 이벤트등도 VS스튜디오의 툴 내에서 손쉽게 지정이 가능하다.

VS C#에서도 이에대해서 충실하게 지원해준다.

보면 왼쪽에 있는 툴박스에서 버튼 컨트롤을 선택한후 오른쪽에 보이는 속성창에서 이벤트등을 생성해 줄수 있다.

MFC와 거의 동일한 인터페이스 이다.

이벤트란 간단히 말해서

버튼을 눌렀다.

창을 키웠다.

창을 움직였다 등을 의미합니다.

그러한 이벤트가 벌어졌을시 특정한 행동을 해라. 라는것이 기본적인 이벤트의 사용법 입니다.

그러한 이벤트가 벌어졌을시 특정한 행동을 해라. 라는것이 기본적인 이벤트의 사용법 입니다.

이번에는 explicit 키워드에 대해 얘기해 보려고 합니다.

최근에 C++ 를 배우신 분들은 모르시겠지만 explicit 키워드는 C++의 첫번째 표준안인 98년 9월 1일 버전에 처음으로 도입된 키워드입니다. Bjarne Stroustrup 이 처음에 C++ 를 창시할 때는 없었다는 거죠. 그럼 왜 98년 C++ 표준안을 출판할 때는 explicit 라는 키워드를 넣었을까요 ? 이런 의문을 제기하지 않고 왜 그런지를 모른다면 C++의 참맛을 안다고 할 수 없겠죠.

결 론부터 말씀드린다면 explicit 키워드는 C 나 C++ 의 공통 특징 중의 하나인 암시적 형변환의 특성때문에 프로그래머가 예상치 못하는 형변환이 일어남으로 인해 정말 발견하기 어려운 버그가 생기는 걸 방지하기 위해서 도입된 키워드입니다.

결론은 그렇다 치는데, 도대체 어떤 버그이길래 그렇게 발견하기 어려운 버그일까요 ? 역시 백마디 말보다 하나의 예가 이해를 돕는데는 제격이므로 예를 들어 한 단계씩 차분히 설명해 보도록 하겠습니다.

일 단, 여러분이 Stack 이라는 클래스를 설계하려고 한다고 해 보죠. 제일 먼저 있어야 할 것은 Stack 객체를 생성하는 생성자가 있어야 할 것입니다. 우선 생각할 수 있는 생성자로는 n 개의 요소까지 가질 수 있는 Stack 을 생성하는 걸 생각해 볼 수 있을 것입니다. 다른 생성자로는 다른 Stack 을 복사해서 생성하는 것, 다른 배열을 복사해서 생성하는 것, 다른 vector 를 복사해서 생성하는 것 등을 생각할 수 있을 것입니다. 이런 생성자를 갖는 Stack 은 다음과 같이 작성할 수 있겠네요.

// 저번에 썼던 코드입니다.
template <typename T>
struct Print {
  void operator() (T v) {
    cout << v << " ";
  }
};
 
class Stack {
private:
  vector<int> _data;
  int _pos;
 
public:
  const static int MIN_ELEM = 10;
 
  // 최대 n 개 요소를 가질 수 있는 Stack 생성자
  // 기본값을 지정해 봤습니다.
  Stack(int n = MIN_ELEM): _data(n), _pos(0) {
    cout << "Stack(int) called" << endl;
  }
 
  // 다른 Stack 을 복사해서 생성하는 복사 생성자
  Stack(const Stack& other): _data(other._data), _pos(other._pos) {
    cout << "Stack(const Stack&) called" << endl;
  }
 
  // 다른 배열을 복사해서 생성하는 생성자
  Stack(int arr[], int n): _data(arr, arr+n), _pos(n) {
    cout << "Stack(int[], int) called" << endl;
  }
 
  // 다른 vector 를 복사해서 생성하는 생성자
  Stack(vector<int> v): _data(v), _pos(v.size()) {
    cout << "Stack(vector<int>) called" << endl;
  }
 
  // 그냥 어떻게 작동하는지 확인하기 위한 디버깅용 멤버 함수
  void printAll() {
    for_each (_data.begin(), _data.end(), Print<int>());
    cout << endl;
  }
};

다음 코드를 수행하면 어떤 결과가 벌어질까요 ? 여러분의 예상과 맞아 떨어지는지 한 번 보시기 바랍니다.

01: int
02: main(void)
03: {
04:   Stack s1;
05:   s1.printAll();
06:   Stack s2(20);
07:   s2.printAll();
08:   Stack s3(s2);
09:
10:   vector<int> v(10, 3);
11:   for_each(v.begin(), v.end(), Print<int>());
12:   cout << endl;
13:
14:   Stack s4(v);
15:   Stack s5 = v;
16:   s1 = v;                 // 이게 어떤 효과를 일으킬까요 ?
17:   s2 = 10;                // 버그 아닌가요 ? 좀 이상하지 않나요 ?
18:
19:   s1.printAll();          // 뭐가 찍힐까요 ?
20:   s2.printAll();          // 뭐가 찍힐까요 ?
21: }

위 코드가 컴파일될까요 ? 특히 17 line은 컴파일이 안될 것 같지 않으세요 ? stack 에 정수값을 할당한다는 게 전혀 말이 안되니 당연히 컴파일 안되어야 정상이겠죠. 자 한 번 컴파일해 볼까요 ? 어! 이게 어떻게 된 거죠 ? 아무런 에러 없이 컴파일이 되네요. 17 line 도 에러 없이 컴파일이 됩니다. 이게 어떻게 된 조화일까요 ? 컴파일러가 왜 이걸 정상적인 코드로 인식하고 컴파일을 했는지를 알려면 우리의 입장이 아니라 컴파일러의 입장에서 생각해 봐야 할 겁니다. 이른바 역지사지 해 보는 것이죠.

17 line 을 만나면 컴파일러는 어떻게 할까요 ? 컴파일러가 하는 일은 자신이 알고 있는 모든 지식을 동원해서 코드를 컴파일 해내는 것입니다. 먼저 s2 에 정수값을 할당할 수 있는 할당 연산자가 있는지 볼 것입니다. 어! 그런데 Stack 클래스 정의를 봤더니 아무리 눈씻고 찾아 봐도 없네요. 프로그래머가 정의한 할당 연산자가 없다면, 컴파일러가 생성한 복사 할당 연산자가 있을 것입니다. 자기가 생성한 복사 할당 연산자를 쓰려고 했더니, 이번에는 10 이라는 정수값이 복사 할당 연산자의 인자와 호환이 되질 않네요. 그렇다고 우리의 C++ 컴파일러는 그냥 컴파일을 포기하고 항복할 녀석이 아니죠. 이번에는 혹시 정수를 복사 할당 연산자의 인자(const Stack& 일 겁니다)로 변환할 수 있는지를 볼 겁니다. 여기에서 C++ 컴파일러는 인자가 하나인 생성자를 암시적 형변환하는데 사용한다는 것을 기억해 보세요. 죽 뒤져 보았더니 Stack(int) 가 눈에 띄네요. 그래서 결국 Stack(10) 을 호출해서 10개의 요소를 갖는 Stack 을 생성하고 그걸 복사 할당 연산자를 이용해서 s2 에 할당하게 됩니다. 이제 그 짧은 코드 안에서 어떤 일이 일어나는지 이해가 되시나요 ?

제가 쓰고 있는 컴파일러(Microsoft Visual C++ 2005)에서 컴파일 후 실행해 봤더니 다음과 같은 결과가 나옵니다.

01: Stack(int) called                         // 04 line 출력
02: 0 0 0 0 0 0 0 0 0 0                       // 05 line 출력
03: Stack(int) called                         // 06 line 출력
04: 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0   // 07 line 출력
05: Stack(const Stack&) called                // 08 line 출력
06: 3 3 3 3 3 3 3 3 3 3                       // 10 line 출력
07: Stack(vector<int>) called                 // 14 line 출력
08: Stack(vector<int>) called                 // 15 line 출력
09: Stack(vector<int>) called                 // 16 line 출력
10: Stack(int) called                         // 17 line 출력
11: 3 3 3 3 3 3 3 3 3 3                       // 19 line 출력
12: 0 0 0 0 0 0 0 0 0 0                       // 20 line 출력

09 ~ 12번째 라인 결과가 좀 의아하지 않나요 ? 왜 이런 결과가 나올까요 ? 눈치 빠른 분들 벌써 회심의 미소를 짓고 계시는 군요. 예, 그렇습니다. 아까 컴파일러 입장에서 살펴 본대로 C++ 의 암시적 형변환 규칙에 따르면 클래스의 생성자 중에 인자가 하나인 생성자들은 프로그래머의 의도와는 전혀 상관없이 컴파일러에 의해 암시적 형변환에 동원되도록 되어 있어서 s1 = v, s2 = 10 이라는 코드를 만나면 각각 Stack(vector<int>), Stack(int) 를 호출하여 임시 객체를 생성하고, 그 임시 객체를 가지고 복사 할당 연산자를 호출하게 됩니다(위 코드 예에서는 컴파일러에 의해 자동 생성된 할당 연산자가 호출되겠죠. 클래스 정의에서 할당 연산자를 여러분 나름대로 정의한 후, cout 으로 뭔가를 출력하게 되면 할당 연산자가 호출되는 것을 확인하실 수 있을 겁니다). 그러고 나면 s1 은 v vector의 내용으로 Stack 을 채우게 될 것이고, s2는 10개의 int 요소로 채우게 될 것입니다. 그래서 결과적으로 09 ~ 12번째같은 결과가 나오는 것이지요. s1 = v 에 대해 Stack(vector<int>) 를 호출하는 건 그래도 어느 정도 말이 된다고 하지만 s2 = 10 에 대해 Stack(int) 를 호출하는 건 좀 오버아닌가요 ? 도대체 Stack 객체에 10을 할당한다는 게 말이 되느냔 말입니다.

C++ 컴파일러는 참 잘난체 하는 데는 이골이 났나 봅니다. 프로그래머가 특별히 정의하지 않더라도 기본 복사 생성자, 복사 할당자를 생성해 버리고, 그것도 모자라 인자가 하나인 생성자를 암시적 형변환하는데 지 맘대로 써 버린다니… 그런데 나름 C++ 컴파일러도 말 못할 고민이 있다고 하네요. C++ 본래 태생이 그래서 그렇답니다. 맘에 안든다고 버릴 수도 없고, 그냥 우리가 적응해서 살아야 되지 않겠습니까 ?

아무리 적응하려고 한다지만 s2 = 10 을 만났을 때 Stack(int) 를 호출하는 건 프로그래머 입장에서는 참 예상하기 힘든 일입니다. 그래서 이런 예상치 못한 수행이 일어나면 프로그래머는 그런 버그를 정말 찾기 힘들게 됩니다. 실제로 이런 일들이 프로젝트 수행 도중 종종 일어나고, 이 버그는 찾기도 정말 힘듭니다. 그러니 아예 이런 일은 피해가는 게 상책이지요. 피해가는 방법이야 s2 = 10 과 같은 코드를 작성하지 않도록 Coding Guideline 에 넣어 두고, Code Review 도 하고 그런 방법도 있겠지만 좀 더 좋은 방법은 아예 s2 = 10 과 같은 코드를 만나면 컴파일시에 에러가 발생해 버린다면 더 좋을 것입니다(항상 기억하세요! 에러는 빨리 발견할 수록 수정하는데 드는 비용이 작다).

그래서, explicit 키워드가 C++의 첫번째 표준안에 새로 도입됐던 것입니다. explicit 키워드는 인자가 하나인 생성자가 암시적 형변환에 쓰이지 않도록 해줍니다. 암시적 형변환에 쓰이면 컴파일 에러가 발생하게 됩니다. 위에 정의한 Stack 정의에서 다음 부분을 수정하신 후에 main()함수를 다시 컴파일해 보시기 바랍니다.

  // 최대 n 개 요소를 가질 수 있는 Stack 생성자
  // 기본값을 지정해 봤습니다.
  explicit Stack(int n = MIN_ELEM): _data(n), _pos(0) {
    cout << "Stack(int) called" << endl;
  }

제가 쓰는 컴파일러에서는 다음과 같은 에러가 발생하네요.

error C2679: binary '=' : no operator found which takes a right-hand operand of type 'int' (or there is no acceptable conversion)

정확히 의도한 바와 같이 컴파일 에러가 발생하네요.

이 상에서 밝힌 바와 같이 explicit 키워드는 C++ 의 특징 중에 하나인 암시적 형변환 때문에 발생할 수 있는 문제의 소지를 미리 예방하는데 유용한 키워드입니다. 그러니, 클래스의 생성자를 설계할 때, 인자가 하나만 있는 생성자에 대해서는 암시적 형변환이 발생할 때 어떤일이 벌어질지를 생각해 보고, 암시적 형변환이 말이 안되는 의미를 갖게 될 경우 explicit 라는 키워드를 꼭 붙이시기 바랍니다. 아니면 거꾸로 생성자에 대해 일단은 무조건 explicit 키워드를 붙였다가 컴파일할 때 암시적 형변환이 허용되지 않아서 너무 불편하다 싶으면 그때가서 빼는 것도 방법입니다. explicit 키워드를 쓴 경우에는 다음과 같이 코드를 작성하시면 암시적 형변환과 같은 의미를 갖는 코드를 작성하실 수 있습니다.

s1 = Stack(v);
s2 = Stack(10);

마지막으로 다음을 기억하신다면 C++의 암시적 형변환 때문에 버그 찾느라 헤메는 일은 없을 것입니다.

Chain of Responsibility(체인 오브 레스포빌리티) 패턴 --------------------------------------------------------------------------------------------

  어떠한 객체를 생성하고 그 인스턴스에 인자값을 통해서 어떠한 요청을 하면 함수는 그에 대한 처리를 할 것입니다.

  하지만 인자값이 분명한데도 잘못된 객체에 집어넣거나.

  혹은 함수에 존재하는 예외처리가 되어 버리는 경우가 있습니다.

  또는 어떠한 요청에 대한 처리가 너무 많아서 하나의 클래스의 크기가 비대해 지는 경우가 있습니다.

  책임연쇄 패턴은 각종 요청에 대해서 그것을 처리할수 있는 객체가 존재할때가지 연속적으로 객체를 탐사하며 요청을 처리할수 있는 객체를 찾아주는 패턴입니다.

패턴적용 스토리 -----------------------------------------------------------------------------------------------

  이번에 적용되는 스토리는 다음과 같습니다.

  당신은 퀘스트시스템을 디자인하게 되었습니다.

  퀘스트 시스템에는 엘프, 오크, 휴먼의 종족이 있고 그에 대한 퀘스트를 할당하기 위한 npc가 각기 다르게 존재합니다.

  하나의 클래스를 통해서 각 요청을 처리할수 있지만 이렇게 되면 그에 따른 분기문과 코드량이 증가할게 뻔해 보입니다.

  이런때 유용하게 사용할수 있는 것이 책임연쇄 패턴입니다.

uml -----------------------------------------------------------------------------------------------

  코드를 보면 알겠지만 데코레이터 패턴처럼 마치 리스트와 같은 구조이다.

  상위의 추상클래스를 기준으로 각 책심을 연쇄시킬 객체들을 서로 연결합니다.

  만약 하나의 연결된 객체중 하나에 요청이 들어오면 자신이 처리할수 없는 요청일 경우에는 자신과 연결된 다음 객체로 다시 요청을 보냅니다.

  그렇게 요청을 연쇄하고 요청을 처리할수 있는 객체가 등장하면 그 요청을 처리하게 됩니다.

코드 -----------------------------------------------------------------------------------------------

결과 ----------------------------------------------------------------------------------------------- 

프록시 패턴 --------------------------------------------------------------------------------------------------

  하나의 객체는 내부적으로 다양한 맴버를 가지고 혹은 포인터를 가질때도 많습니다.

  혹은 하나의 거대한 이미지나 데이터를 사용하기 용이하게 하기 위한 객체로 디자인 되기도 합니다.

  하지만 실제 게임이나 프로그램을 보면 한 유저가 게임을 실행하고 게임내의 모든 데이터를 사용하는 경우는 거의 없습니다.

  온 지역을 돌아다니며 모든 몬스터를 만다고 모든 아이템을 한꺼번에 모두 가지고 있는 경우는 희귀한 편이고

  게임 디자인또한 그런식으로 되지 않습니다.

  대리자 패턴은 그런 경우 꼭 필요한 객체만을 생성하고 그 함수를 이용할수 있게 해주거나.

  가벼운 일은 가벼운 객체만 생성해서 해결하고 실제 아직 요청되지 않은 무거운 객체는 나중에 생성하게 하는 패턴입니다.

패턴적용 스토리 -----------------------------------------------------------------------------------------------

  이번에 적용되는 스토리는 다음과 같습니다.

  당신은 아이템 클래스의 정보와 랜더를 맡게 되었습니다.

  아이템의 기능은 크게 2가지 입니다.

  인벤창에 있을때 아이템에 대한 데이터를 보여준다.

  장착 했을때 캐릭터에게 3dmash 이미지를 띄워준다.

  아이템 인포는 매우 작은 작업니다.

  하지만 3가지 분류의 1000가지가 넘는 아이템이 있고 실제 그 아이템을 플레이어가 모두 소유하고 있지는 않기 때문에 필요할때만

  매쉬를 생성하고 마찬가지로 필요할 때만 아이템에 대한 정보를 로드하기로 했습니다.

uml -----------------------------------------------------------------------------------------------

보시면 알겠지만 플라이웨이트 패턴과 결합되어 있는 구조입니다.

대리 객체인 CItemProxy 클래스는 내부에 자신과 같이 CitemBase를 상속받고있는 CItem 클래스를 보유하고 있습니다.

내부적으로 3가지 아이템의 생성에 대해서 관여하고 있으며 각 플라이웨이트패턴의 캐쉬들에 대해서 직접적인 요청을 하는것은 아이템 프록시 패턴입니다.

일정부분 패턴을 나갔기 때문에 여러가지 패턴이 섞여있고 응용성을 높여 봤으니 구조를 잘파악하면서 확인해 봐야 합니다.

하지만 중요한 것은 하나의 가상클래스를 상속받는 프록시클래스와 실제 동작을 담당하는 리얼클래스가 존재하며

프록시 클래스는 리얼클래스를 내부에 포함한 상태로 그 객체를 통해서 실제 동작을 정의한다는 것이 중요한 것입니다.

또한 플라이 웨이트 패턴에서는 기존의 객체의 로딩을 최소화 하는데만 그치지 않고

내부적으로는 아무런 객체도 가지고 있지 않다고 요청이 들어왔을때 존재하면 포인터를 리턴해주고

존재하지 않는다면 내부적으로 파일을 탐색하여 그때그때 진정으로 필요한 객체만 생성하는 방식을 사용하고 있으니 그점에 대해서도 잘 확인해야 합니다.

플라이 웨이트 패턴 --------------------------------------------------------------------------------------------------

  일반적으로 포인터나 주소값은 대부분 같은 것을 참조할 때가 많습니다.

  하지만 대부분의 객체가 이러한 포인터 값을 다수 가지고 있다면 메모리에 대한 부담이 커질수가 있습니다.

  그래서 하나의 자료구조에 포인터를 모아놓고 사용해야할 객체들이 그 정보들을 전역변수처럼 돌려쓰는 것이

  대표적인 것이 이미지에 대한 정보 입니다. 완전히 같은 이미지를 사용하는 2개의 객체가 있을때.

  굳이 2개의 이미지를 로딩하는 것이 아니라. 1개만 로딩한후 그것을 돌려쓰면 됩니다.

패턴적용 스토리 -----------------------------------------------------------------------------------------------

  당신에게 오브젝트 랜더에에 대한 임무가 내려졌습니다.

  오브젝트 랜더를 위해서는 이미지가 필요한데.

  각 오브젝트마다 이미지를 로딩해 봤더니 이미지에 대한 데이터부담이 너무 커졌습니다.

  그래서 당신은 플라이웨이트 패턴을 사용하여 만약 오브젝트들이 같은 이미지를 랜더한다면 그 이미지를 한번만 로딩하기로 결정했습니다.

uml -----------------------------------------------------------------------------------------------

플라이 웨이트패턴을 보면 오브젝트에서는 CFlyTexture에 있는 stl자료구조 안에 담긴 텍스처의 포인터를 가져와서 랜더를 합니다.

즉 프로토타입처럼 하나의 이미지를 다수의 오브젝트가 공유하여 사용하는 패턴입니다.

코드 -----------------------------------------------------------------------------------------------

결과 -----------------------------------------------------------------------------------------------

시간을 알려주는 구조체이다. 사용법은 아래와 같고.

자세한 내용은 msdn의 구조체 항목에서 datetime 구조체를 참고하면 된다.

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace ConsoleApplication1

{

    class Program

    {

        static void Main(string[] args)

        {

            DateTime dt = DateTime.Now;

            string str;

            str = string.Format("금일은 {0}년 {1}월 {2}일({3})이다", dt.Year, dt.Month, dt.Day, dt.DayOfWeek);

            Console.WriteLine(str);

            str = string.Format("현재 {0}시 {1}분 {2}초({3})이다", dt.Hour, dt.Minute, dt.Second, dt.Millisecond);

            Console.WriteLine(str);

            str = string.Format("dt.Date {0}", dt.Date);

            Console.WriteLine(str);

            str = string.Format("짧은 날짜 형식 {0}", dt.ToShortDateString());

            Console.WriteLine(str);

        }

    }

}

namespace ConsoleApplication1

{

    struct MyData

    {

        public int x, y;

        public MyData(int x, int y)

        {

            this.x = x;

            this.y = y;

        }

        public MyData(ref int x, ref int y)

        {

            this.x = 0;

            this.y = 0;

        }

        public void NoShow()

        {

            Console.WriteLine("no swap");

            Console.WriteLine("{0}        {1}", this.x, this.y);

        }

        public void Show()

        {

            Console.WriteLine("swap");

            Console.WriteLine("{0}        {1}", this.x, this.y);

        }

    }

    class MyDataClass

    {

        public int x = 10, y = 100;

        public void NoShow()

        {

            Console.WriteLine("No swap");

            Console.WriteLine("{0}        {1}", x, y);

        }

        public void Show()

        {

            Console.WriteLine("swap");

            Console.WriteLine("{0}        {1}", x, y);

        }

    }

    class Swap

    {

        static public void CSwapdata(MyDataClass md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

        static public void CSwapdata1(ref MyDataClass md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

        static public void Swapdata(MyData md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

        static public void Swapdata1(ref MyData md)

        {

            int temp;

            temp = md.x;

            md.x = md.y;

            md.y = temp;

        }

    }

    class Program

    {

        static void Main(string[] args)

        {

            MyData Md = new MyData(10, 100);

            MyData Md1;

            Md1.x = 10;

            Md1.y = 100;

            Console.WriteLine("new struct value");

            Md.NoShow();

            Swap.Swapdata(Md);

            Md.Show();

            Console.WriteLine("new struct ref");

            Md.NoShow();

            Swap.Swapdata1(ref Md);

            Md.Show();

            Console.WriteLine("value struct value");

            Md1.NoShow();

            Swap.Swapdata(Md1);

            Md1.Show();

            Console.WriteLine("value struct ref");

            Md1.NoShow();

            Swap.Swapdata1(ref Md1);

            Md1.Show();

            MyDataClass CMd = new MyDataClass();

            Console.WriteLine("class value swap");

            CMd.NoShow();

            Swap.CSwapdata(CMd);

            CMd.Show();

            Console.WriteLine("class ref swap");

            CMd.NoShow();

            Swap.CSwapdata1(ref CMd);

            CMd.Show();

        }

    }

}

구문이 좀 길지만 실행해보면 차이를 알수 있다.

구조체의 경우 ref로 참조하지 않을 경우 원본의 데이터를 바꿀수 없다.

이것은 구조체를 new로 할당하거나 그냥 할당해도 마찬가지이다.

클래스의 경우에는 반대이다. 어떤 방식으로 넣어도(ref로 넣던 값형으로 넣던) 내부의 데이터를 변경할수가 있다.

즉 클래스는 애초부터 참조형 형태의 데이터이고 구조체의 경우에는 값형 데이터이며 이 차이를 명확하게 인식해야 한다.

빠르게 배워나가는 도중이기 때문에 변수나 함수에 대해서 깊게 파고 있지는 않았다.

하지만 C#에서는 몇가지 새로운 경고와 변수의 사용시점등이 약간 다른 면이 있어서 다음과 같이 정리해 보았다.

    class aaa

    {

        private int c = 0; -> 선언 순간 초기화. 봐도 신기하기는 하다.

        public void a()

        {

            this.c = 1;

        }

    }

위의 클래스를 컴파일 하면 다음과 같은 경고가 뜬다.

경고 CS0414: 'ConsoleApplication1.aaa.c' 필드가 할당되었지만 그 값은 사용되지 않습니다.

사용되지 않았다? 그냥 상수 값의 대입은 컴파일러가 사용하지 않았다라고 판단하는 것 같다.

그럼 어떤때 사용했다고 할까?

    class aaa

    {

        private int c = 100;

        public void a()

        {

            int dd = 100;

            this.c = dd; -> 이 녀석을 대입하면 사용했다고 본다. 상수가 지역변수등을 혹은 public void a(int temp) { this.c = temp;} 같은 식도 된다.

            b(this.c); -> 아무것도 없는 함수지만 내부에 넣었다는 것만으로도 사용한 것으로 본다.

        }

        public void b(int a)

        {

        }

        public void p()

        {

            Console.WriteLine(c); -> 마찬가지다.

        }

        public aaa(int a)

        {

            this.c = a; -> 생성자를 만들어서 대입해주면 역시나 사용했다고 인식한다.

        }

    }

인덱서란? ------------------------------------------------------------------------------------------------------------------------

  인덱서란 내부에 존재하는 맴버변수나 혹은 인스턴스를 배열과 같이 취급하는 것을 인덱서라고 한다.

  문법적으로는 C#의 속성의 배열 버전이라고 보면 된다 보인다.

    class SampleCollection<T>

    {

        private T[] arr = new T[100]; -> 어라 클래스의 맴버변수를 내부에서 그냥 초기화 해버린다. 가능했구나...

  private int c = 0; -> 이렇게 굳이 할당을 하지 않아도 가능하다.

        public T this[int i] -> 이녀석이 인덱서이다. this구문을 무조건 붙여줘야 한다.

        {

            get

            {

                return arr[i]; -> 내부 인스턴스의 값을 배열적인 측면으로 접근이 가능하다.

            }

            set

            {

                arr[i] = value; -> 마찬가지로 대입도 가능하다.

            }

        }

    }

    // This class shows how client code uses the indexer

    class Program

    {

        static void Main(string[] args)

        {

            SampleCollection<string> stringCollection = new SampleCollection<string>();

            stringCollection[0] = "Hello, World"; -> 객체에서 즉각 접근이 가능해진다.

            stringCollection[1] = "World, Hello"; -> 배열이니 인덱스를 바꾸는 것도 마찬가지.

            System.Console.WriteLine(stringCollection[1]);

        }

    }