[KLA 멀티캠퍼스] C#7.0 제대로 배우기 Part.1(입문1)

22.07.14 (1~7차시)

 

[C#의 역사]

: C언어 -> C++ -> C#

 

C언어에서 부족했던 OOP(객체지향)를 추가해서 C++를 만듬.

Window 운영체제, Office 프로그램, Adobe 사의 프로그램들이 C++로 만들어짐.

 

C#: C++언어를 발전시킨 언어. Microsoft사의 Anders Hejisberg가 개발. .NET Framework에 최적화된 언어. (인터넷 서비스를 쉽게 개발할 수 있도록 라이브러리를 제공해주는 프로그램을 의미하는 .NET도 Microsoft사가 만듬)

---

[4~5차시 C# 데이터 타입]

bool: True or False

 

- 정수형

byte: 8비트. unsigned 정수형 (integer)

sbyte: 8비트 signed 정수형

(u)short: 16비트 (un)signed 정수형

(u)int: 32비트 (un)signed 정수형 <- System.Int32

(u)long: 64비트 (un)signed 정수형

 

- 실수형

float: 32비트 실수형

double: 64비트 실수형 <System.Double

decimal: 128비트 실수형

 

- 문자열형

char: 16비트 유니코드 문자

string: 유니코드 문자열 <- System.String

 

 

[데이터형의 최대값 확인하는 법]

int aa = int.MaxValue; -> 2147483648

int aa_ = int.MinValue; -> -2147483647 

long형: -9223372036854775808 ~ 9223372036854775807

 

 

[Literal 리터럴 데이터]

: 123, True, "AGC" 와 같은 값들을 Literal 이라 한다.

- 리터럴의 형식(타입): 123(int 리터럴), 11.11(double 리터럴), "B"(string 리터럴), 'b'(char 리터럴), True(bool 리터럴) 이라고 표현한다.

---

[C# 컴파일러]

: C# 컴파일러가 int, double, char, string, bool 데이터 타입에 기본적으로 그에 해당하는 값을 할당한다.

 

cf) 데이터 타입별 접미사(Suffix)를 사용해서 특정 데이터 타입을 지정할 수 있다.

접미어: L(long형), U(unsigned int형), UL(unsigned long형), F(float형), D(double형), M(decimal형)

ex) long l = 12322L; 이면 long 형의 실수만 l 변수에 넣는다는 뜻.

---

[6차시 - Null과 Nullable 타입의 이해]

NULL: 어떤 변수가 데이터를 가지고 있지 않을 때 표현하는 방법. 즉, 메모리 상에 어떤 데이터도 갖고 있지 않을 때 사용하는 키워드.

Null을 가질 수 있는 데이터 타입(Reference 타입)이 따로 있다. 대표적으로 string 타입.

Null을 가질 수 없는 데이터 타입(Value 타입): int, DateTime...

 

Nullable: HasValue와 Value 속성을 갖고 있다.  값을 갖고 있으면 true, 값을 갖고 있지 않으면 false.

Nullable 형식을 적용하면 정수 같은 Value Type도 null 값을 가질 수 있다.

즉, 값이 비어있는 Nullable Type의 변수를 선언할 수 있다.

"?" 키워드 사용.

 

ex) int? a = null; 이렇게

---

[7차시 - Value Type과 Reference Type의 이해]

- 구조체: Value Type(값 형식: 변수가 값을 담는 데이터 형식)

- 클래스: Reference Type(참조 형식: 변수가 실제 값 대신에 값이 있는 위치를 담는 데이터 형식)

 

 

* 메모리 영역: Stack / Heap

1) Stack

값 형식과 관련

} 블록 끝을 만나면 생성된 메모리가 모두 사라진다. 알아서 메모리 비움.

} 블록이 끝나도 그 데이터를 갖고 있고 싶으면 Heap 영역을 사용해야 한다. 

 

2) Heap

참조 형식과 관련

메모리를 알아서 지우지 못해서 모두 참조된 후 가비지 컬렉터를 사용해서 지움.

Object 형식의 변수

 

cf) 참조 형식은 힙과 스택을 함께 이용한다.

Heap 영역에 실제 데이터를 저장하고

Stack 영역에는 실제 데이터가 저장되어 있는 Heap의 메모리 주소가 저장된다.

그렇게 되면 } 을 만나서 Stack 영역은 날라가도 Heap 영역은 날라가지 않아서 데이터를 보존할 수 있다.

---

22.07.15 (8~9차시)

 

[8차시 - Boxing과 UnBoxing의 개념]

 

* Object 형식

- C#은 모든 데이터(int, string, float 등)를 다룰 수 있는 Object 형식을 제공하고 있다.

즉, C#의 컴파일러는 어떤 형식의 데이터라도 Object 형식에 담아 처리할 수 있게 하고 있다.

 

ex)

object obj1 = 111;
object obj2 = 3.141212121212m; //decimal 형태의 데이터를 object에 넣은 것.
object obj3 = true;
object obj4 = "하이 Csharp!";

 

object obj1 = 111;

111은 int형 값이고 obj1은 object형의 참조형식의 변수이다. 따라서 111이라는 값은 Heap 에 저장된다. object형이 참조형식이니깐.

이 때, boxing 기능을 통해 Heap에 저장된다. 정수 그 자체는 Heap 에 저장될 수 없으므로 111이 Box에 담겨서 Heap에 저장되는 것.

UnBoxing은 Boxing 되어 있는 값을 꺼내 값형식(Value Type) 변수에 저장하는 과정을 의미한다.

 

ex)

int x = 111;
object obj1 = (object)x; // x에 담겨있는 값을 Boxing해서 Heap에 저장.
int y = (int)obj1; // UnBoxing 후에 Stack에 저장.

---

[9차시 데이터 형변환(Type Conversion)]

: 소괄호가 () 컨버전 연산자.

: 데이터 형식 변환이란. 변수를 다른 데이터 형식에 옮기는 것.

 

* 형변환 Case. 형변환할 때 데이터 손실을 막자.

1) 크기가 서로 다른 정수형 사이의 형변환

sbyte a = 127; 
Console.write(sbyte.MinValue); //-128
Console.write(" ~ ");
Console.writeLine(sbyte.MaxValue); //127
Console.WriteLine(a); // 127
int aa = (int)a;
Console.WriteLine(aa); // 127. 정상. sbyte 범위내에 들어옴.
int x = 128;
Console.WriteLine(x); // 128
sbyte xx =(sbyte)x;
Console.WriteLine(xx); // -128. 오버플로우. 자릿수가 넘어가며 부호비트의 영향으로 생기는 현상.

 

2) 크기가 서로 다른 부동소수점 사이의 형변환

float f = 79.6777f;
Console.WriteLine("f: {0}", f); //79.6777
double d = (double)f;
Console.WriteLine("d: {0}", d); //79.6776962280273

double dd = 0.11212121212f;
float ff = (float)dd;
Console.WriteLine("ff: {0}", ff); // 0.1121212. 데이터 손실났음.

십진수를 이진수로 바꿀 때, 십진수의 소수점자리가 이진수로 변환했다가 다시 10진수로 변환한다. 이진수가 소수점 계산이 완벽하지 않기 때문에, 이 과정에서 데이터 손실이 난 것.

 

22.07.15 (10차시)

 

3) 부호있는 정수형과 부호없는 정수형 사이의 형변환

byte(부호없음), sbyte(부호있음)

short(부호있음), ushort(부호없음)

int(부호있음), uint(부호없음)

 

byte(8비트): 0 ~ 255

sbyte(8비트): -127 ~ 128

 

ex)

부호가 없는 경우,

0000 0000

0000 0001 = 1

0000 0011 = 3

0000 0111 = 7

0000 1111 = 15

...

1111 1111 = 255

 

부호가 있는 경우,

0111 1111 = 127

0000 0011 = 3

0000 0111 = 7

0000 1111 = 15

...

0111 1111 = 127

1111 1111 = -1

: 8자리 비트에서 맨 첫번째 비트는 부호비트이므로 최대값은 2^6 + 2^5 + 2^4 + 2^3 + 2^2 + 2^1 + 2^0 = 127까지 표현 가능하다.

: 음수는 2의 보수로 표현되기 때문에  1111 1111 은 -127이 아니라 -1이다. 

 

** 2의 보수표현법

0000 0001 의 2의 보수를 구해보자. 1) 0000 0001을 비트 반전시켜준다.    1111 1110 2) 반전된 비트에 1을 더한다.        1111 1110 + 0000 0001 ㅡㅡㅡㅡㅡㅡㅡ       1111 1111 => 0000 0001의 2의 보수 = 1111 1111 => -1

 

2의 보수로 표현을 안했다면,

  0000 0001

+  1111 1111

ㅡㅡㅡㅡㅡㅡㅡ

  0000 0000 (1이 한자리 넘어가서 8자리로 표현할 수 없기 때문에 0이 된다. 값이 달라짐.)

 

따라서 부호가 있는 경우 1111 1111 은 -1 이다. 

 

4) 실수형과 정수형 사이의 형변환

float f = 4.72134f; // 4.72134
int aa = (int)f; // 4 (소수점자리 걍 버림)

 

5) 문자열과 숫자 사이의 형변환

문자열 -> 숫자: ToString() 이용

string str1 = "12222";
int num1 = (int)str1; // error!

int num2 = 12222;
string str2 = (string)num2; // error!

int num3 = 343434;
string str3 = num3.ToString(); // 343434. ok!

float num4 = 1212.1212f;
string str4 = num4.ToString(); // 1212.12. ok!

숫자 -> 문자열: Parse 이용

string str1 = "121212"
int num1 = int.Parse(str1); // 121212

string str2 = "1.1234562"
float num1 = float.Parse(str1); // 1.123456 -> 정수형 1자리 포함해서 7자리 수만 표현 가능. 그 뒤 숫자는 버림.

 

 

22.07.21 (11~13차시)

[11차시 - 상수(Constants) / 12차시 - enum형의 이해]

* 변수: 담고 있는 데이터를 얼마든지 변경할 수 있는 메모리공간

* 상수: 담고 있는 데이터를 절대 바꿀 수 없는 메모리 공간. const 라는 키워드를 사용한다.

 

* 열거형 상수(enum)

enum 열거형식명 : 자료형 {상수1, 상수2, 상수3}

 

정수형(byte, sbyte, short, ushort, int, unit, long, char) 자료형만 사용된다

자료형을 생략했을 경우 int 형으로 설정된다.

 

ex)

enum City { Seoul, Incheon, Daegu, Daejeon }

 

열거형식 안에 선언된 상수들이 어떤 값도 할당 되지 않았을 경우에는

첫번째 상수 요소에는 0이라는 값이 할당됨. 그리고 그 다음 요소에는 1, 2, 3...

컴파일러가 자동으로 Counting 해서 할당 함.

 

 

22.07.22(14차시)

*비트연산자(쉬프트, &, |, ^)

1) 쉬프트 연산

int aa = 1, bb = 2, cc = 3;

Console.WriteLine("{0:x8}", aa);//0001. 16진수 8자리를 표현하는 법. x가 16진수를 나타냄.
Console.WriteLine("{0:D3} 0x{0:X8}", aa);//001 0x00000001. (00000001 = 1 이라서)
Console.WriteLine("{0:D3} 0x{0:X8}", aa << 1);//002 0x00000002. (00000010 = 2 라서)
Console.WriteLine("{0:D3} 0x{0:X8}", aa << 5);//032 0x00000020.(00100000 = 32 라서)
Console.WriteLine("aa:{0} bb:{1} cc:{2}", aa, bb, cc); //특정형식에 맞춰 출력하는 포맷팅(Formatting) 기능


int a = 100;
Console.WriteLine("{0:D}:", cc); //3
Console.WriteLine("{0:D5}", cc); //00003
Console.WriteLine("{0:D5}:", a); //00100

cf) 16진수는 4비트 필요. 0~15

 

 

22.07.22(15~19차시)

*비트연산

: &(AND연산), |(OR연산), ^(XOR연산), ~(보수연산)

int x = 9;
int y = 10;

Console.WriteLine(x & y); //8. 1001 과 1010 의 AND 연산
Console.WriteLine(x | y); //11. 1001 과 1010 의 OR 연산
Console.WriteLine(x ^ y); //3. 1001 과 1010 의 XOR 연산

int xx = 255;

Console.WriteLine("{0} 0x{0:x8} {1} 0x{1:x8}", xx, ~xx); // 255 0x000000FF -256 0xFFFFFF00

0 1111 1111(255)을 보수연산하면 1 0000 0000(-256)이 된다.

왜 1 0000 0000이 -255가 아니라 -256일까?

 

그 이유는 256인 1 0000 0000 의 2의 보수를 구해보면 알 수 잇겟지.

 

<2의 보수 구하는 법>

먼저 256인 1 0000 0000 를 비트반전 시켜서 1의 보수를 구한다. => 0 11111 11111

그리고 0 11111 11111 에 1을 더한다. => 1 0000 0000.

 

즉, 1 0000 0000(256)의 2의 보수가 1 0000 0000 이므로 1 0000 0000은 10진수 표현에서 -256이 되는 것이다.

 

 

[18차시 - 배열과 foreach문]

* 배열(Array): 일련의 동일한 데이터 타입 요소들로 구성된 데이터 집합

 

1) 1차원 배열 선언

데이터형식[ ] 배열이름 = new 데이터형식[배열의크기];

int arr[] = new int[5];

2) 2차원 배열 선언

데이터형식[ , ] 배열이름 = new 데이터형식 [2차원크기, 1차원크기]

int[,] arr = {{1,10,100}, {5,50,500}};

 

* GetLength(): 배열에서 지정한 차원의 길이를 구하는 메소드

int[,] arr = {{1,10,100},{5,50,500}};

for(int i = 0; i<arr.GetLength(0); i++){
	for(int j = 0; j<arr.GetLength(1); j++){
    
    }
}

: [,] 에서 앞이 2차원 길이. 뒤가 1차원 길이 이므로 헹, 열 길이로 보면 된다.

 

* foreach문

foreach(데이터형식 변수명 in 배열/컬렉션)        반복코드

 

 

22.07.27(20~25차시) 끝!

3) 가변배열(Jagged Array) 선언

데이터 형식[][] 배열이름 = new 데이터형식[가변배열의 크기][];

****가변배열의 크기는 필수적으로 들어가야 함 !

 

예시)

int[][] arr = new int[3][];
arr[0] = new int[5]{1,2,3,4,5};
arr[1] = new int[3]{11,22,33};
arr[2] = new int[2]{20,30};

int[][] arr2 = new int[2][];
arr2[0] = new int[]{1,22,333,4444,55555};

//행은 설정해놓고 열을 맘대로 만들 수 있음

int[][] jArr = new int[3][];
jArr[0] = new int[4] {1, 2, 3, 4};
jArr[1] = new int[] {10, 11, 12, 22, 33, 44};
jArr[2] = new int[] {20, 30};

foreach (int[] arr in jArr){
	Console.WriteLine("Length: {0}, ", arr.Length); //4, 6, 2 나옴
}

 

[22차시 - 참조에 의한 매개 변수 전달]

1) 값으로 전달할 때

: a, b 를 값으로 전달하면 a, b 변수가 달라지는게 아니라 x, y라는 변수를 새로 만든다. 새로운 메모리 주소에 할당된다.

 

2) 참조로 전달할 때: ref 키워드

static void Main(string[] args){
	int aa = 100;
	int bb = 111;
    
    Console.WriteLine("aa: {0}, bb: {1}", aa, bb); // 100, 111
    Swap(ref aa, ref bb);
    Console.WriteLine("aa: {0}, bb: {1}", aa, bb); // 111, 100
}

static void Swap(ref int x, ref int y){
	int temp = x;
    x = y;
    y = temp;
}

: x, y 가 aa, bb 를 참조한다.

 

 

[23차시 - 오버로딩, 파라미터 디폴드 값 주기]

* 메소드 오버로딩: 같은 메소드 이름인데 매개변수(매개변수 수, 매개변수 타입)를 달리 선언해서 만드는 것.

* 파라미터에 기본값 적용하기: void aaa(int a = 0, int b = 1){ ... }

 

[24차시 - 로컬함수]

* var 키워드: 데이터 형식을 알아서 C#컴파일러가 지정한다.

 

로컬함수: 메소드 안에서 선언된 특별 함수. 메소드 안에서 선언되었기 때문에 클래스 멤버가 아니다. 함수라고 부른다.

class Program{
	static string ToLowerStar(string str){
        var arr = str.ToCharArray();
        for(int i = 0; i<arr.Length; i++){
        	arr[i] = ToLowerChar(i);
        }
    }
    char ToLowerChar(int i){
    	if(arr[i] < 65 || arr[i] > 90)
        	return arr[i];
        else
        	return (char){arr[i] + 32);
    }
    return new string(arr);
}

 

[25차시 - 클래스와 객체]

OOP: Object Oriented Programing

 

*객체는 속성(명사), 기능(동사)을 갖고 표현한다. -> 객체: 클래스. 속성: 변수, 기능: 함수...