기록

파이썬은 읽고 쓰기 쉽고 프로그래머의 작업 효율을 높이도록 디자인된 프로그래밍 언어이다.

윈도우, 맥 os, 리눅스는 물론 라즈베리 파이 등 다양한 운영체제를 지원한다. 이러한 장점들이 수많은 사용자를 이끌었고 거기에 따라서 자료도 찾기 쉬워 접근성이 더 높아지면서 그에 따라 더욱더 성장할 가능성이 있는 언어라고 볼 수 있다.

라이브러리

파이썬의 가장 큰 특징은 풍부한 라이브러리이다. 

문법이 간단해서 코드를 작성하는 데는 어려움이 없지만 무언가를 만들기 위해서는 목적에 맞는 라이브러리를 사용할 필요가 있다. 

파일을 읽고 쓰고, 네트워크에 접근하는 등 표준으로 준비돼 있는 것뿐만 아니라 서드파티가 공개하는 것도 많다.

대표적으로 유명한 라이브러리들이 있다.

NumPy                수치 계산 라이브러리
SciPy                   과학 기술 계산 라이브러리
PIL                       영상처리 라이브러리
Tkinter                  GUI 라이브러리
Beautiful Soup      HTML 정보 수집(스크래핑) 라이브러리
PyGame               게임 작성용 라이브러리

PyGame

python 3.8 버전을 기준으로 작업한다. 

게임을 개발하는데 필요한 라이브러리를 설치한다.

Anaconda

아나콘다는 파이썬에서 자주 쓰이는 패키지를 일괄적으로 설치할 수 있도록 한다.

Free Download | Anaconda

경로에 한글이 포함되어 있으면 에러가 발생할 수 있기 때문에 아나콘다를 설치하는 경로에는 한글이 포함되지 않도록 해주는 것이 좋다.

이때 환경변수를 Anaconda 폴더 내의 python.exe 가 실행되도록 경로를 맞춰야 한다.

게임에서 사용할 패키지를 설치한다.

pip install pygame

Error

다음과 같은 에러가 발생하면  pip이 설치되지 않아서 발생할 수 있기 때문에 직접 설치한다.

'pip'은(는) 내부 또는 외부 명령, 실행할 수 있는 프로그램, 또는 배치 파일이 아닙니다.

pip은 보통 파이썬을 설치된다. 만약 이때 설치되지 못했다면 직접 명령어를 통해서 설치한다.

curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py
python get-pip.py

명령어를 입력하는 방법 외에도 python 인스톨러를 다시 실행시켜서 pip 설치에 대한 체크를 하고 파이썬 설치를 진행해도 된다.

pip 설치 후 다시 pygame 명령어 실행 시 제대로 설치가 된다.

완료된 패키지 파일을 실행시켜 설치한다.

python
import pygame

설치가 완료되면 다음 경로에 샘플이 생성된 것을 확인할 수 있다.

'[Anaconda 설치 경로]\Lib\site-packages\pygame\examples'

세팅 끝

프로그래밍에 대한 공부를 어느 정도 진행했을 무렵 다양한 언어들 중 평가가 좋은 언어를 따로 체크해 두고 학습해 보기로 하였다. 그렇게 미루고 미루다 언젠가 서점에서 책 하나가 눈에 들어왔다.

마침 체크리스트에는 파이썬도 있었다.

프로그래밍 언어는 특히 새로운 것을 학습할 때는 무언가를 만들면서 하는 게 쉽고 빠르게 습득이 된다고 생각한다.

게임으로 파이썬을 배울 수 있다는게 흥미가 생겨 목차만 대강 훑어보고 바로 구매하였다.

이 책을 시작으로 파이썬에 대해서 기본이라도 얻어갈 수 있게 된다면 의미가 있을 거라고 생각한다.

 책의 저자인 다나카 겐이치로는 파이썬을 배우기 위해서 입문서도 읽고 세미나도 다녔지만 익숙해지지 않았는데 자바스크립트로 만든 게임을 파이썬에 이식했더니 금방 익숙해졌다고 한다. 그래서 게임을 만들면서 파이썬을 배울 수 있도록 이 책을 만들었다.

또한 저자는 파이썬이 적용될 수 있는 분야가 다양하고 가능성이 무한하다고 하는데 역자 또한 동일한 맥락으로 도입글을 작성했다. 파이썬은 간결하고 쉬우며 방대한 기능을 하는 라이브러리가 매력적이라고 한다.

커뮤니티나 포탈에서도 파이썬에 대한 호평을 많이 봐왔는데 시작하는 글에서 다시 보게 되니 과연 파이썬이 얼마나 쉽고 간다 하며 활용성이 좋은 것일까 기대가 된다.

Collections

. Net Framework에서 사용되던 라이브러리이다. Generic 기능이 도입되기 이전에 사용되었으며 Collections의 클래스들은 모든 요소를 object 타입으로 처리하여  요소를 다룰 때에 형변환을 필요로 한다.

대표적의로 ArrayList, Hashtable, sortedList, Stack, Queue 등이 있다.

Generic

Collections의 클래스들은 형변환이 필요하기 때문에 잘못된 타입을 사용할 경우 에러가 발생하게 된다. 

이 문제를 해결하기 위해서 안정성을 제공하는 새로운 클래스들이 Generic 네임스페이스로 추가되었다.

대표적으로 List, Dictionary, Queue <T>, Stack <T> 등이 있다.

Compare

옛날부터 작성된 코드인 경우에는 Collections 라이브러리를 사용하기 위해서 해당 네임스페이스를 선언해 주는 경우가 많다. 거기다 새로 추가된 Generic도 사용하기 위해서 두 라이브러리를 모두 선언하는 경우가 많은데 공식 문서에 따르면 Collections에서 사용하는 클래스들은 Generic에 안정성이 추가된 대체할 수 있는 클래스들이 있기 때문에 되도록이면 Generic만 사용하기를 권장한다.

대표적으로 ArrayList와 List<T>를 비교해 본다. 

using System;
using System.Collections;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // ArrayList
        ArrayList arrayList = new ArrayList();

        // 요소 추가
        arrayList.Add("Hello");
        arrayList.Add(30);
        arrayList.Add(true);

        // 요소 접근
        string str = (string)arrayList[0];
        int num = (int)arrayList[1];
        bool flag = (bool)arrayList[2];

        Console.WriteLine(str);  // 출력: Hello
        Console.WriteLine(num);  // 출력: 30
        Console.WriteLine(flag); // 출력: True
        
        // List<T>
        List<object> list = new List<object>();

        // 요소 추가
        list.Add("Hello");
        list.Add(30);
        list.Add(true);

        // 요소 접근
        string str = list[0];
        int num = list[1];
        bool flag = list[2];

        Console.WriteLine(str);  // 출력: Hello
        Console.WriteLine(num);  // 출력: 30
        Console.WriteLine(flag); // 출력: True
    }
}

arrayList와 list 변수 모두 가변 배열로 요소를 추가하고 인덱스로 접근하여 값을 사용하고 있다.

하지만 사용법에서 차이가 발생한다.

ArrayList는 Add 메서드를 사용하여 요소를 추가하고 접근할 때에는 형변환을 수행해야 한다. 모든 요소를 object 타입으로 처리하므로 요소를 사용하기 전에 타입을 캐스팅해야 한다.

하지만 List 요소의 타입은 컴파일 시점에 검사 되기 때문에 추가한 요소에 접근할 때 형변환이 따로 필요하지 않다. 

즉 Generic을 사용하게 되면 타입의 안정성이 보장되고 컴파일러가 타입을 검사를 수행하기 때문에 타입으로 인해 발생하는 문제를 사전에 발견할 수 있으며 형변환 코드를 작성할 필요가 없기 때문에 코드가 간결해진다.

C#은 객체지향 언어로 객체지향 프로그래밍을 위한 개념들이 있다.

Class

객체를 정의하는 템플릿이며 객체의 상태를 나타내는 필드와 동작을 나타내는 메서드를 포함한다.

즉 클래스는 객체를 표현하기 위한 설계도로 볼 수 있다.

public class MyClass
{
    // field, 멤버 변수
    public int id;
    public string name;
    public int age;
    
    // method, 멤버 함수
    public void Introduc()
    {
        string introduce = "My age : " + agem + "\nMy name : " + name;
    	Cosole.WriteLine(introduce);
    }
}

MyClass라는 객체에는 id, name, age 멤버변수와 Introduce 메서드를 포함하고 있다.

Instance

클래스의 인스턴스로 실제로 메모리에 할당된 데이터이다. 객체는 클래스에서 정의된 필드와 메서드를 사용할 수 있으며 개별적인 상태를 유지한다.

public void Main(string[] args)
{
    // Instance, MyClass 클래스의 객체
    MyClass myClass = new MyClass();
    myClass.id = 1;
    myClass.name = "bak";
    myClass.age = 30;
    myClass.Introduce();
    
    // Instance, myClass와는 개별적인 객체
    MyClass myClass2 = new MyClass();
    myClass2.id = 2;
    myClass2.name = "kim";
    myClass2.age = 25;
    myClass2.Introduce();
}

동일한 MyClass를 인스턴스화한 myClass와 myClass2는 개별적인 객체이다.

Inherit

클래스 간의 계층 구조를 형성하여 코드의 재사용성과 구조화를 실현한다. 기존 클래스를 기반으로 새로운 클래스를 정의하고 확장할 수 있는데 ㅅ상속을 통해 부모 클래스의 멤버를 자식 클래스에서 사용하는 것이 가능하다.

public class Parent
{ 
    public int id;
    public string name;
    
    public void MethodParent()
    {
    	Console.Log(id, name);
    }
}

public class Child
{
    public void MethodChild()
    {
    	id = 10;
        name = "bak";
        MethodParent();
    }
}

재사용할 코드는 부모 클래스로 만들어서 자식 클래스에서 상속하여 그대로 사용할 수 있다.

Polymophism

다형성은 같은 이름의 메서드나 속성을 다른 방식으로 구현하는 개념이다. 다형성은 상속과 관련이 깊으며 부모 클래스의 타입으로 자식 클래스의 객체를 참조하면 다형성을 활용할 수 있다.

public class Parent
{
    public virtual void MethodParent()
    {
    	Console.WriteLine("Call Parent Method");
    }
}

public class Child
{
 	public override void MethodParent()
    {
    	Console.WriteLine("Call Parent Method From Child");
    }
}

다형성의 대표적인 예는 부모 클래스의 메서드를 자식에서 오버라이딩하는 경우가 있다.

Encapsulation

객체의 상태와 동작을 외부로부터 감추는것을 뜻한다.  클래스는 필드와 메서드를 적절한 접근 제한자로 제어하여 캡슐화를 구현할 수 있다. 이는 객체의 내부 구현을 보호하며 외부에서는 필요한 기능만 사용할 수 있도록 한다.

public class MyClass
{
    private string name;
    private int age;
    
    public void SetName(string name)
    {
    	this.name = name;
    }
    
    public string GetName()
    {
    	return name;
    }
    
    public void SetAge(int age)
    {
    	this.age = age;
    }
    
    public int GetAge()
    {
    	return age;
    }
}

public class Program
{
    public static void Main(string[] args)
    {
    	MyClass myClass = new MyClass();
        myClass.SetName("Bak");
        myClass.SetAge(30);
        Console.WriteLine("Name : " + myClass.GetName());
        Console.WriteLine("Age : " + myClass.GetAge());
    }
}

클래스에서 접근을 허용할 부분을 public 불필요한 부분은 private로 접근 제한자를 두어 필요한 부분만 제어할 수 있도록 한다.

Abstract

복잡한 시스템을 단순화하고 핵심적인 요소만을 추출하여 모델링하는 과정을 말한다. 추상화는 클래스의 공통적인 특징을 추출하여 부모 클래스나 인터페이스로 정의할 수 있다.

public class Person
{
    public int age;
    public string name;
    public int countryCode;
    
    public virtual void Eat() {}
    public virtual void Sleep() {}
    public virtual void Work() {}
}

public class Student : Person
{
    public override void Work()
    {
    	Console.WirteLine("Studying");
    }
}

public class Teacher : Person
{
    public override void Work()
    {
    	Console.WriteLine("Teaching");
    }
}

추상화는 클래스를 만들 때 필요한 기본 개념으로 재사용, 다형성 등을 고려하여 최대한 구체적이지 않으면서 공통적인 부분을 부모 클래스로 만들 때 필요하다.

is

주어진 값이 특정 클래스 혹은 구조체의 인스턴스인지 아닌지를 판별하는 연산자이다.

즉, is 연산자는 해당 값이 주어진 클래스 또는 구조체로부터 상속되었거나 해당 구조체와 일치하는지를 판별하는 데 사용된다.

object obj = "Hello World!";
if (obj is string)
{
	Console.WriteLine("obj is a string");
}

is 키워드는 obj 변수가 string 타입에 해당하는지 검사한다.

만약 obj가 string 타입이면 로그가 출력되는데 string은 object의 파생 클래스이기 때문에 object 형식으로 형변환이 가능하며 해당 조건문은 true로 로그가 출력이 된다.

as

참조 타입의 변수에서 형식 변환을 수행하는 연산자이다.

as 연산자를 사용하면 형식 변환 작업을 수행하면서 실패한 경우 null을 반환한다.

object obj = "Hello World!";
string str = obj as string;
if (str != null)
{
	Console.WriteLine(str,ToUpper());
}
else
{
	Console.WriteLine("obj is not a string");
}

object 타입인 obj를 as를 사용해서 string으로 형변환을 하였다. 

당연히 object는 string으로 형변환이 가능하기 때문에 해당 결과는 true로 결과가 출력된다.

is 만 사용할 경우 암시적으로 형변환이 일어나는데 이때 예외처리 에러가 발생할 수 있다. as를 사용해서 형변환을 시도한 결과를 null 예외처리를 할 수 있기 때문에 is와 as는 함께 많이 사용된다.

sizeof

피연산자의 크기를 바이트 단위로 계산하여 반환하는 연산자이다.

이 연산자는 컴파일 타임에 실행되며 모든 유형과 식을 피연산자로 취급이 가능하다.

// sizeof(type)
int size = sizeof(int);

sizeof 연산자는 스택에 메모리를 할당할 때 유용하다. 정확한 크기를 알고 있는 배열을 만들 때 sizeof 연산자를 사용하여 각 요소의 크기를 계산하고 이를 기반으로 배열의 크기를 계산할 수 있다.

하지만 sizeof 연산자는 값 형식의 객체에 대해서만 사용할 수 있으며 참조 형식에 대해서는 사용이 불가능하다.

참조 타입의 경우 인스턴스 크기를 얻기 위해서는 Marshal.Sizeof() 메서드를 사용할 수 있지만 이 메서드는 해당 인스턴스가 저장된 메모리의 크기를 반환하므로 실제 인스턴스의 크기와는 다를 수 있다.

typeof 

특정 타입의 System.Type 객체를 반환하는데 이를 통해 코드에서 지정한 타입에 대한 정보를 얻을 수 있다. 

컴파일 타임에 타입을 검사하기 때문에 코드의 안정성과 가독성을 높일 수 있으며 객체의 타입을 확인하고 이에 따라 적절한 작업을 수행하는 코드를 작성할 수 있다.

// typeof(Type)
Type t = typeof(int);

해당 타입의 System.Type 객체를 반환한다. C#에서 사용되는 모든 타입에 대한 정보를 담고 있으며 해당 타입에 대한 모든 메타데이터를 포함하고 있다.

t 변수는 int 타입의 System.Type 객체를 참조하게 되며 이를 통해 int 타입에 대한 정보를 얻을 수 있다.

이외에도 다양한 타입에 대한 정보를 typeof 연산자를 통해 얻을 수 있다.

stackalloc

고정 크기의 메모리 블록을 동적으로 할당하기 위해서 사용한다.

메모리 할당과 해제가 매우 빠르고 GC에 의해서 관리되는 힙 메모리를 사용하지 않으므로 애플리케이션의 성능을 향상할 수 있다. C/C++의 alloca() 함수와 비슷한 역할을 한다. 

하지만 alloca과 다르게 stackalloc은 호출된 함수의 실행이 종료될 때 자동으로 메모리가 해제되게 된다.

Span<int> numbers = stackalloc[] { 1, 2, 3, 4, 5 };
var idx = numbers.IndexOfAny(stackalloc[] { 2, 4, 6, 8 });
Console.WriteLine(idx);

포인터 형식으로도 메모리 할당이 가능하다.

unsafe
{
	int length = 3;
    int* numbers = stackalloc int[lenth];
    for (var i = 0; i < length; i++)
    {
    	numbers[i] = i;
    }
}

포인터 형식을 사용할 경우 지역 변수에서만 stackalloc을 사용하여 변수를 초기화 할 수 있다.

루프 내부에서는 stackalloc을 사용하지 않아야하며 루프 외부에서 메모리 블록을 할당하고 루프 내부에서 사용하는 방식으로 가야 한다.

스택에서 사용 가능한 메모리는 제한적이기 때문에 너무 많은 메모리를 할당하게 되면 스택오버플로우 에러가 발생한다.

이 문제를 방지하기 위해서는 할당하려는 버퍼의 크기가 특정 한도 내에서만 할당되도록 제한을 두어야 한다.

const int MaxStackLimit = 1024;
Span<byte> buffer = inputLength <= MaxStackLimit ? 
					stackalloc byte[inputLength] : new byte[MaxStackLimit];

입력한 버퍼의 크기가 최대 크기보다 작으면 입력한 만큼의 버퍼를 할당하고 최대를 벗어날 경우에는 최대크기만큼만 버퍼를 할당하도록 한다.

새로 할당된 메모리는 반드시 사용 전에 초기화가 필요하다. 이때 모든 형식의 기본값으로 설정할 수 있는 Span<T>.Clear 메서드를 사용할 수 있다.

checked/unchecked

정수 연산 시 overflow 발생 여부를 처리하는 데 사용한다.

기본적으로 C#에서 정수형 연산은 오버플로우가 생기면 예외가 발생한다. 이 예외를 처리하기 위해서는 try-catch 문을 사용해야 하는데 이는 코드를 복잡하게 만들 수 있기 때문에 이런 상황에서는 checked와 unchecked 키워드를 사용할 ㅅ ㅜ있다.

int x = int.MaxValue;
int y = 1;

checked
{
	int z = x + y;
}

unchecked
{
	int z = x + y;
}

 위 코드는 int의 최댓값이 1을 더하는 것으로 OverflowException이 발생하는 코드이다.

이때 checked를 사용하면 계산과정에서 overflow가 나기 때문에 예외가 발생한다.

unchecked를 사용할 경우에는 overflow가 발생해도 예외를 발생시키지 않고 결과를 진행한다.

int a = int.MaxValue;
int b = unchecked(a + 1);
int c = checked(a + 1); // System.OverflowException 예외 발생

params

메서드의 매개 변수로 배열을 받을 수 있게 해주는 키워드이다.

params 키워드를 사용하면 메서드 호출 시 각각의 인자를 전달해서 배열형식으로 전달할 수 있다.

만약 배열이나 리스트와 같은 타입을 인수로 전달해야 하는 경우 리스트나 배열로 선언해서 값을 넣어줘야 한다.

public void Main(string[] args)
{
	int[] arrI = new int[4]{1,2,3,4}
    MyMethod(arrI);
}

public void MyMethod(int[] values){}

이럴 때 호출할 함수의 매계변수를 params로 선언하면 따로 배열로 묶어줄 필요가 없어진다.

public void Main(string[] args)
{
	MyMethod(1, 2, 3, 4);
}

public void MyMethod(params int[] values)
{
	foreach (int value in values)
    {
    	Console.WriteLine(value);
    }
}

params 키워드를 통해서 인자를 각각의 인덱스에 값을 넣는 형식으로 받아서 사용이 가능하다.

ref

reference 즉, 참조를 뜻하는 키워드이다.

이 키워드를 사용해서 값 타입을 참조 타입처럼 사용할 수 있다.

static void Swap(int a, int b)
{
	int temp = a;
    a = b;
    b = temp;
}

인자로 받은 두 값을 서로 바꾸는 메서드이다.

int는 값 형식으로 값의 복사만 이루어지기 때문에 위 메서드는 a와 b의 값이 바뀌지 않는다.

이때 ref 키워드를 사용하면 참조를 하게 되므로 본래의 변수들의 값이 수정된다,

static void Swap(ref int a, ref int b)
{
	int temp = 4;
    a = b;
    b = temp;
}

이렇게 ref 키워드를 사용해서 메서드를 정의하게 되면 호출하는 곳에서도 ref 키워드를 붙여서 인자를 전달해야 한다.

int x = 1;
int y = 2;
Swap(ref x, ref y);

C++의 포인터와 비슷한 개념이다.

하지만 포인터는 메모리 주소를 가리키는 변수이고 ref는 메모리 위치를 직접 가리키는 것이 아닌 해당 객체에 대한 참조를 가리키게 된다.

따라서 ref 키워드를 사용하면 참조형식 변수를 함수에 전달하여 함수 내에서 해당 변수가 참조하는 메모리 위치를 직접 조작할 수 있다. 이를 통해 함수 내에서 해당 변수가 가리키는 객체를 직접 수정하는 것이 가능하다.

out 

메서드에서 값을 반환하는 것 외에도 메서드 호출 이후에 값을 전달할 수 있는 방법을 제공한다,

즉 out 키워드를 사용하면 메서드 내부에서 매개변수 값을 수정할 수 있고, 수정된 값을 호출한 곳에서 가져다 쓸 수 있다.

키워드는 메서드의 매개변수 앞에 붙여서 사용한다. 

public void Calculate(int x, int y, out int sum, out int product)
{
	sum = x + y;
    product = x * y;
}

Calculate 메서드는 x, y 두 매개변수를 받는다. 그리고 out 키워드를 사용해서 sum, product 두 개의 매개변수를 추가로 받고 있다.

해당 메서드 내부에서는 전달받은 x, y를 이용해서 sum, product를 계산한 후 각각의 매개변수에 값을 할당한다.

이후 메서드를 호출할 때 sum, product를 담을 변수를 선언하고 이 변수를 매개변수로 넘겨주어야 한다.

int a = 5;
int b = 10;
int totalSum = 0;
int totalProduct = 0;

Calculate(a, b, out totalSum, out totalProduct);

Console,WriteLine(totalSum + " " + totalProduct);

메서드가 호출되면 Calculate 내부에서는 전달받은 a와 b의 가지고 각각 totalSum의 값과 totalProduct의 값을 계산하여 저장한다. 따라서 함수의 호출 이후에 totalSum과 totalProduct의 값은 계산 결과가 담기게 된다.

Namespace

네임스페이스는 다른 식별자와 구분하기 위한 식별자의 집합을 의미한다.

즉, 클래스, 구조체, 인터페이스, 델리게이트, enum 등의 데이터 형식, 메서드, 변수 등을 구별하기 위한 컨테이너 역할을 한다. 

예를 들어 클래스명 같은 경우 일반적으로 흔히 사용하는 이름으로 작명한 경우 다른 패키지를 설치하여서 사용하다 보면 동일한 클래스명으로 인해서 충돌이 발생할 수 있다. 이럴 때 클래스를 자신만의 네임스페이스로 지정해서 구분해 두면 이름이 중복되더라도 namespace.class와 같이 구분해서 접근되기 때문에 에러를 방지할 수 있다.

public class MyClass{}

namespace MyScript
{
	public class MyClass{}
}
// 네임스페이스로 인해 동일한 이름의 두 클래스는 구분 된다.

MyScript 네임스페이스로 싸여진 MyClass를 사용하기 위해서는 MyScript에서 사용할 것임을 명시해야 한다.

using

코드에서 다른 네임스페이스를 가져오기 위해 사용된다.

네임스페이스로 싸인 클래스를 사용하기 위해서는 해당 네임스페이스를 명시한 뒤에 그 내부의 클래스에 접근이 가능하다.

namespace MyScript
{
	public class MyClass{}
}

public void Main(string[] args)
{
	MyScript.MyClass() myClass = ...
}

만약 네임스페이스로 싸여진 클래스의 사용이 빈번해지게 되면 매번 명시해 주는 것이 번거롭고 코드의 가독성을 떨어뜨리게 된다.

이때 using을 통해서 사용할 네임스페이스를 전역으로 선언할 수 있다.

using MyScript;

~

public void Main(string[] args)
{
	MyClass myClass = ... // using으로 인해서 MyScript의 MyClass임을 알 수 있다.
}

그럼에도 동시에 동일한 클래스명을 가지게 되는 경우에는 코드 앞에 네임스페이스를 명시해주어야 한다.

operator

연산자 오버로딩을 정의하는 데 사용되는 키워드이다. 

산술, 비교, 논리 등의 연산자를 재정의하여 다른 연산을 수행하도록 한다. 

예를 들어 내가 만든 타입의 경우 내장 연산자에는 정의되어있지 않기 때문에 계산이 불가능한데 이때 오버로딩을 해서 내가 만든 타입을 연산자로 처리하고 결과를 리턴할 수 있다.

public static MyClass operator +(MyClass a, MyClass b)
{
	// add MyClass a and b
    return result;
}

public void Main(string[] args)
{
	MyClass myClass1 = new MyClass();
    MyClass myClass2 = new MyClass();
    
    // 오버로딩한 내용으로 결과를 반환받게 된다.
    MyClass result = myClass1 + myClass2;
}

내가 만든 클래스 타입의 MyClass 두 개를 + 연산하기 위해서 + 연산자를 오버로딩했다.

원하는 결과를 얻기 위해서는 내부에서 필요한 동작을 구현하면 MyClass 결과를 return 받을 수 있다.

extern alias

다른 어셈블리를 참조할 때 사용되는 지시어이다.

일반적으로 프로젝트에서는 하나 이상의 어셈블리를 참조해야 하는데 두 개 이상의 어셈블리가 같은 이름을 가지고 있는 경우 이를 구분하기 위해서 extern alias를 사용할 수 있다.

extern alias A1;
extern alias A2;

A1::SomeNamespace.SomeClass someObjcet = new A1::SomeNamespace.SomeClass();
A2::SomeNamespace.SomeClass anotherObjcet = new A2::SomeNamespace.SomeClass();

A1과 A2는 각각 어셈블리의 별칭으로 이를 이용해서 어셈블리의 이름을 지정할 수 있다. 이렇게 구분지은 어셈블리는 동일한 이름을 가지고 있더라도 참조할 때 충돌하지 않는다.

:: operator

:: 연산자는 extern alias 지시어를 사용해 참조된 어셈블리 내의 형식을 참조하기 위해서 사용한다.

System 네임스페이스에 있는 COnsole 클래스를 사용하고자 할 때 System.Console로 사용할 수 있지만 다른 어셈블리에 있는 System 네임스페이스의 Console을 사용하고자 할 때는 extern alias 지시어를 사용한 구분이 필요하다.

extern alias aliasName;
aliasName::System.Console.WriteLine("Hello World");

여기서 aliasName은 다른 어셈블리에서 사용할 alias 이름을 지정하는 데 사용된다.

:: 연산자는 aliasName과 System.Console을 구분하는 데 사용한다.

this

인스턴스 특정

현재 인스턴스를 가리키는 기능을 한다.

주로 멤버 메서드나 생성자에서 인스턴스 변수를 참조할 때 사용한다.

class Person {
    private string name;
    private int age;

    public Person(string name, int age) {
        this.name = name;
        this.age = age;
    }

    public void PrintInfo() {
        Console.WriteLine("Name: " + this.name);
        Console.WriteLine("Age: " + this.age);
    }
}

이와 같은 경우 this 키워드는 동일한 이름의 name과 age를 멤버와 매개변수를 구분하는 데 사용된다.

PrintInfo 내에서는 this를 사용하지 않고 호출해도 되지만 일관성을 유지하기 위해 사용하는 등 개발자의 선호도에 따라 사용여부가 다르다.

생성자 호출

다른 생성자를 호출할 때 사용할 수 있다.

class Person {
    private string name;
    private int age;

    public Person(string name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(string name) : this(name, 0) {
    }

    public void PrintInfo() {
        Console.WriteLine("Name: " + this.name);
        Console.WriteLine("Age: " + this.age);
    }
}

위와 같이 두 개의 오버로딩된 생성자가 선언되었을 때 string name 매개변수만 받는 생성자의 경우 호출될 때 Person(string name, int age) 생성자를 호출하며 이때 age 값을 0으로 호출하는 동작이 수행된다.

인덱서

인덱서는 클래스나 구조체 등의 객체를 배열처럼 인덱싱할 수 있게 해주는 것으로 대괄호 안에 인덱스를 전달하여 객체의 멤버 변수나 속성 값을 가져오거나 설정할 수 있다.

public class MyList
{
    private string[] _data = new string[10];

    public string this[int index]
    {
        get => _data[index];
        set => _data[index] = value;
    }
}

class Program
{
    static void Main(string[] args)
    {
        MyList list = new MyList();
        list[0] = "Hello";
        list[1] = "World";
        Console.WriteLine(list[0]); // "Hello" 출력
        Console.WriteLine(list[1]); // "World" 출력
    }
}

this 키워드로 정의된 인덱서는 string 형식의 배열 _data 멤버 변수를 instance [indexer]와 같이 바로 접근하여 사용할 수 있다. 

인덱서를 사용하지 않을 경우에는 해당 멤버에 접근하기 위해서 별도의 public 프로퍼티나 메서드 또는 _data를 public으로 선언해야 한다.

base

상위 클래스로부터 파생된 클래스에서 사용할 수 있는 키워드로 상위 클래스의 멤버에 액세스 할 때 사용된다.

예를 들어 상위 클래스에서 정의된 멤버를 파생 클래스에서 다시 구현할 때 base 키워드를 사용하면 상위 클래스의 멤버에 접근할 수 있다.

public class Parent{
	virtual public void CallFunc(){
    	Console.WriteLine("Parent Call");
    }
}

public class Child : Parent{
	override public void CallFunc(){
    	base.CallFunc();
        Console.WriteLine("Child Call");
    }
}

Child child = new Child();
child.CallFunc();
// Parent Call, Child Call 모두 출력됨

struct

값 형식을 나타내는 키워드이다.

struct로 정의된 데이터 타입은 클래스와 비슷한 멤버를 가질 수 있지만 다른 특징이 있다.

클래스와 차이

struct는 클래스와 달리 상속이나 인터페이스 구현 등의 기능을 제공하지 않으며 struct는 메모리에 적재되며 개체의 인스턴스화를 할 수 있다. 또한 struct는 기본적으로 stack에 할당되어 heap 메모리를 사용하지 않기 때문에 일반적인 값 형식을 나타내기 위해서 사용된다.

struct는 변수에 값을 할당할 때 복사가 일어나게 된다. 예를 들어 struct로 정의된 Point 타입의 변수에 값을 할당하면 해당 값을 복사하여 새로운 메모리 공간에 저장한다.

struct Point
{
	public int X;
    public int Y;
}

Point p1 = new Point{X = 10, Y = 20};
Point p2 = p1;	// 이때 p1의 값 전체가 복사되어 p2에 저장된다.

구조체가 메모리에 할당될 때 데이터 멤버들 사이에는 일정한 간격을 두고 배치된다. 

이 간격을 Padding이라고 하며 데이터 멤버의 크기와 정렬을 고려해 계산된다. 이는 구조체 전체 크기가 미리 예측 가능하기 위해서이며 이 크기는 구조체 전체 크기 합에 패딩을 합한 값이다.

패딩은 구조체의 크기를 불필요하게 늘리기도 하므로 크기를 최소화하기 위해서는 큰 데이터를 먼저 선언하고 뒤에 작은 데이터들이 선언되도록 멤버들을 크기에 따라 정렬하는것이 좋다. 이렇게 구조체를 제대로 이해하고 사용하기 위해서는 각 타입들의 크기와 패딩의 존재에 대해 정확한 이해가 필요하다.