IT가 만드는 재기 넘치는 세상

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //이항 연산자
            //+, -, *, /, % 
            int a = 28;
            int b = 10;
            
            Console.WriteLine("{0} + {1} = {2}", a, b, a + b);
            Console.WriteLine("{0} - {1} = {2}", a, b, a - b);
            Console.WriteLine("{0} * {1} = {2}", a, b, a * b);
            Console.WriteLine("{0} / {1} = {2}", a, b, a / b);
            Console.WriteLine("{0} % {1} = {2}", a, b, a % b);

            //C# 에서는 다른 언어와 다르게 실수 % 연산이 됩니다.
            float f1 = 3.141592f;
            float f2 = 2.141592f;
            float result = f1 % f2;
            Console.WriteLine("{0} % {1} = {2}", f1, f2, result);
        }
    }
}

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //복합 할당 연산자
            //+=, -=, *=, /=, %=
            int a = 28;
            int b = 10;
            
            Console.WriteLine("{0}", a += b);
            Console.WriteLine("{0}", a -= b);
            Console.WriteLine("{0}", a *= b);
            Console.WriteLine("{0}", a /= b);
            Console.WriteLine("{0}", a %= b);
        }
    }
}

결과

복합 할당 연산자의 경우 값을 할당함에 있어 a 와 b 의 연산이후 다시 a에 값을 재할당 하는것을 의미합니다.

a = a+b 와 같은 결과 값을 가집니다. 재할당의 기준은 왼쪽 피연산자에게 연산이후 재할당 합니다.

값의 변화에 대해 디버깅을 통해 하나씩 확인해 봅시다.

강좌 2장에서 언급한 디버그 모드의 기능을 활용하면 쉽게 값의 변화를 알수 있습니다.

이 기능은 프로그램에 버그가 발생하였을때 자주 사용하는 기능으로 매우 중요합니다.

디버그 모드

① 디버깅을 하고 싶은 곳에 클릭

② F9번을 누르면 왼쪽에 붉은색 브레이크 포인트가 생성

③ 디버그 모드인 F5번을 누르면 프로그램 시작과 함께 브레이크 포인트가 있는 곳에서 코드 실행 정지

    값이 보고싶은 변수위에 마우스를 올려 놓으면 값을 확인가능

④ 디버그 모드일때 주변 인터페이스가 변경 되는것을 확인 할수 있는데 하단에 조사식1 탭을 사용하여

    변수의 값을 추적하며 확인할수 있음 ( 변수를 클릭 드래그하여 블럭을 씌운뒤 조사식1 탭으로 옴겨놓음)

※ 코드가 실행 정지 되었을때 다시 F5번을 누르면 다음 브레이크 포인트로 이동이 됩니다.

디버그 모드일때 추가로 확인하고 싶은 곳이 있다면 해당 위치를 클릭후 F9을 눌러 브레이크 포인트를

추가하실수 있습니다. 코드 실행이 정지된 상태에서 F10을 누르면 다음 라인까지 코드실행 F11을 누르면

다음 라인까지 코드가 실행되지만 다른 참조된 라이브러리까지 차례로 들어가서 코드가 실행되는 것을

확인하실수 있습니다.

논리 연산자

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //논리 연산자
            //>, <, >=, <=, ==, !=
            int a = 1;
            int b = 2;
            int c = 2;

            Console.WriteLine("a > b = {0}", a > b);
            Console.WriteLine("a < b = {0}", a < b);
            Console.WriteLine();

            Console.WriteLine("a >= b = {0}", a >= b);
            Console.WriteLine("a <= b = {0}", a <= b);
            Console.WriteLine("b <= c = {0}", b <= c);
            Console.WriteLine();

            Console.WriteLine("a == b = {0}", a == b);
            Console.WriteLine("b == c = {0}", b == c);
            Console.WriteLine("a != b = {0}", a != b);
            Console.WriteLine("b != c = {0}", b != c);
        }
    }
}

결과

※ 논리 연산 결과가 맞다면 True 틀리다면 False로 리턴됩니다.

이항 논리 연산자

논리곱( && : AND) 연산

두개의 값이 모두 True일 경우에만 True

논리합( || : OR) 연산

두개의 값중 하나라도 True이라면 True

부정( ! : NOT) 연산

True라면 False, False 라면 True

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //이항 논리 연산자
            //&&, ||, !
            Console.WriteLine("논리곱(AND) 참 && 참 = {0}", true && true);
            Console.WriteLine("논리곱(AND) 참 && 거짓 = {0}", true && false);
            Console.WriteLine("논리곱(AND) 거짓 && 참 = {0}", false && true);
            Console.WriteLine("논리곱(AND) 거짓 && 거짓 = {0}", false && false);
            Console.WriteLine();

            Console.WriteLine("논리합(OR) 참 || 참 = {0}", true || true);
            Console.WriteLine("논리합(OR) 참 || 거짓 = {0}", true || false);
            Console.WriteLine("논리합(OR) 거짓 || 참 = {0}", false || true);
            Console.WriteLine("논리합(OR) 거짓 || 거짓 = {0}", false || false);
            Console.WriteLine();

            Console.WriteLine("부정(!) !참 = {0}", !true);
            Console.WriteLine("부정(!) !거짓 = {0}", !false);
        }
    }
}

결과

비트 이항 연산자

비트 연산자를 알기에 앞서 컴퓨터의 최소 데이터 단위는 Bit로 0과 1을 사용하는 2진수을 사용합니다.

1byte의 데이터는 0000 0000과 같습니다.

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //비트 이항 연산자
            //&, |, ^, <<, >>
            byte a = 15;
            byte b = 5;
            string s = "";

            s = Convert.ToString(a, 2).PadLeft(8, '0');      //8자리의 비트로 표현하기 위해 사용한 코드
            Console.WriteLine("a     : {0}, Bit : {1} ", a, s);
            s = Convert.ToString(b, 2).PadLeft(8, '0');
            Console.WriteLine("b     : {0} , Bit : {1} ", b, s);
            Console.WriteLine();

            s = Convert.ToString(a&b, 2).PadLeft(8, '0');
            Console.WriteLine("a & b : {0} , Bit : {1} ", a & b, s);
            Console.WriteLine();

            s = Convert.ToString(a | b, 2).PadLeft(8, '0');
            Console.WriteLine("a | b : {0}, Bit : {1} ", a | b, s);
            Console.WriteLine();

            s = Convert.ToString(a ^ b, 2).PadLeft(8, '0');
            Console.WriteLine("a ^ b : {0}, Bit : {1} ", a ^ b, s);
            Console.WriteLine();

            s = Convert.ToString(a << 1, 2).PadLeft(8, '0');
            Console.WriteLine("a << 1 : {0}, Bit : {1}", a << 1, s);

            s = Convert.ToString(a << 2, 2).PadLeft(8, '0');
            Console.WriteLine("a << 2 : {0}, Bit : {1}", a << 2, s);
            Console.WriteLine();

            s = Convert.ToString(a >> 1, 2).PadLeft(8, '0');
            Console.WriteLine("a >> 1 : {0}, Bit : {1}", a >> 1, s);

            s = Convert.ToString(a >> 2, 2).PadLeft(8, '0');
            Console.WriteLine("a >> 2 : {0}, Bit : {1}", a >> 2, s);
        }
    }
}

결과

비트연산은 최고의 연산속도를 자랑합니다. 프로그램 최적화나 최소한의 데이터를 이용하여 연산을 하기위해 사용 합니다.

컴퓨터 입장에서는 다른 추상화된 정보와 달리 별도의 과정없이 의미가 해석되어 전달 되기때문에 빠를수 밖에 없습니다.

a(15) : 0000 1111,  b(5)  : 0000 0101

증감 연산자

전위, 후위로 나뉘는데 기본적으로 ++는 값에 1을 증가 시키거나 1을 감소 시키는 연산자 입니다.

전위의 경우 값을 먼저 증가 시키고 코드가 실행되며 후위의 경우 코드가 실행되고 값이 증가 됩니다.

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //증감 연산자
            //++, --

            int a = 1;

            Console.WriteLine("현재 값      : {0}",   a);
            Console.WriteLine();

            Console.WriteLine("전위 증가 값 : {0}", ++a);
            Console.WriteLine("후위 증가 값 : {0}", a++);
            Console.WriteLine("현재 값      : {0}", a);
            Console.WriteLine();

            Console.WriteLine("전위 감소 값 : {0}", --a);
            Console.WriteLine("후위 감소 값 : {0}", a--);
            Console.WriteLine("현재 값      : {0}", a);
        }
    }
}

결과

삼항 연산자

코드를 짜다보면 가독성이라는 말을 많이 하게 됩니다. 코드가 한눈에 들어오고 읽기 편한 코드 형태를

가독성이 좋다라고 말합니다. 삼항 연산자는 가독성을 올리고 간단한 논리의 오류가 적어보일때 사용하면 좋습니다.

(논리) ? 논리가 참 일때 참조되는 값 : 논리가 거짓 일때 참조되는 값

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //삼항 연산자
            //? :
            int num1 = 10;
            int num2 = 20;
            int numTrue = 77;
            int numFalse = 88;
            
            int r = (num1 > num2) ? numTrue : numFalse;
            Console.WriteLine(r);
        }
    }
}

결과

if문과 짝이되는 문법 : if, else if, else

if (조건식 1) // 예) a > b
            {
                //조건식 1이 참인 경우 중괄호 안의 코드 실행
            }
            else if (조건식 2) //예) a < b
            {
                //조건식 1이 거짓이고 조건식 2가 참인 경우 중괄호 안의 코드 실행
            }
            else
            {
                //모든 조건식이 거짓인 경우 중괄호 안의 코드 실행
            }

if문은 다양하게 사용가능 합니다.

-if 단독으로 사용

-if, else if 사용 가능

-if, else 사용 가능

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 10;
            int b = 20;

            if(a > b)
                Console.WriteLine("a는 b보다 크다");

            if(a > b)
                Console.WriteLine("a는 b보다 크다");
            else
                Console.WriteLine("a는 b보다 크지 않다");


            if(a == b)
            {
                Console.WriteLine("a와 b는 같다");
            }
            else if(a < b)
            {
                Console.WriteLine("b는 a보다 크다");
            }
            else
            {
                Console.WriteLine("a는 b보다 크다");
            }
        }
    }
}

결과

if, else if, else의 중괄호 {, }는 제외가 가능하지만 한줄 이상의 코드에서는 오히려 가독성이 떨어지고 버그를 유발할수 있습니다.

switch 문

switch 문과 짝이 되는 문법 : switch, case, break, default

switch (조건식1)
{
    case 조건식: //해당 조건식1 형식( 정수, 문자, 문자열 )에따라 조건식을 써야 합니다.
        {
            //조건식과 같다면 중괄호 안의 코드 실행
            //break를 만나면 switch문을 빠져나감
            break;
        }
    case 조건식: //순차 적으로 case 단위로 비교되고 조건식과 같다면 중괄호 안의 코드 실행
        {
            break;
        }
    default: //모든 case를 비교하였지만 같은 조건식이 없다면 중괄호 안의 코드 실행
        {
            break;
        }
}

switch문은 조건식1에 따라 위에서 아래로 순차적으로 case와 비교 진행되며 default문은 제외 가능합니다.

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 13;
            switch (a)
            {
                case 10:
                    {
                        Console.WriteLine("a 는 10 이다");
                        break;
                    }
                case 13:
                    {
                        Console.WriteLine("a 는 13 이다");
                        break;
                    }
            }
            Console.WriteLine();


            string str = "파랑";
            switch (str)
            {
                case "빨강":
                    Console.WriteLine("좋아 하는 색은? {0}", str);
                    break;
                case "노랑":
                    Console.WriteLine("좋아 하는 색은? {0}", str);
                    break;
                case "파랑":
                    Console.WriteLine("좋아 하는 색은? {0}", str);
                    break;
                default:
                    Console.WriteLine("좋아 하는 색이 없다");
                    break;
            }
        }
    }
}

결과

case의 중괄호 {, }는 제외 가능하나 코드가 늘어나면 가독성이 떨어지고 실수를 할수 있습니다.

코드는 명확한것이 가장 좋고 여러사람이 한 프로젝트를 공유하여 개발할때 가독성을 떨어트리거나 자신만 알아볼수 있는 코드는

삼가 해야됩니다.

다음장에서는 반복문과 제어문에 대해 알아보도록 하겠습니다.

수고하셨습니다.

<데이터 형식 표>

소스코드

using System;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int a = 10;
            Console.WriteLine("int 형 Max : {0} ~ Min : {1} size : {2}byte", int.MaxValue, int.MinValue, sizeof(int));
            Console.WriteLine(a);

            uint b = 10;
            Console.WriteLine("uint 형 Max : {0} ~ Min : {1} size : {2}byte", uint.MaxValue, uint.MinValue, sizeof(uint));

            short c = 10;
            Console.WriteLine("short 형 Max : {0} ~ Min : {1} size : {2}byte", short.MaxValue, short.MinValue, sizeof(short));

            ushort d = 10;
            Console.WriteLine("ushort 형 Max : {0} ~ Min : {1} size : {2}byte", ushort.MaxValue, ushort.MinValue, sizeof(ushort));

            long e = 10;
            Console.WriteLine("long 형 Max : {0} ~ Min : {1} size : {2}byte", long.MaxValue, long.MinValue, sizeof(long));

            ulong f = 10;
            Console.WriteLine("ulong 형 Max : {0} ~ Min : {1} size : {2}byte", ulong.MaxValue, ulong.MinValue, sizeof(ulong));

            byte g = 10;
            Console.WriteLine("byte 형 Max : {0} ~ Min : {1} size : {2}byte", byte.MaxValue, byte.MinValue, sizeof(byte));

            sbyte h = 10;
            Console.WriteLine("sbyte 형 Max : {0} ~ Min : {1} size : {2}byte", sbyte.MaxValue, sbyte.MinValue, sizeof(sbyte));

            char i = 'A';
            Console.WriteLine("char 형 size : {0}byte", sizeof(char));

            float j = 1.41421356237f;
            Console.WriteLine("float 형 Max : {0} ~ Min : {1} size : {2}byte", float.MaxValue, float.MinValue, sizeof(float));
            Console.WriteLine("{0}", j);

            double k = 1.41421356237d;
            Console.WriteLine("double 형 Max : {0} ~ Min : {1} size : {2}byte", double.MaxValue, double.MinValue, sizeof(double));
            Console.WriteLine("{0}", k);

            decimal l = 10m;
            Console.WriteLine("decimal 형 Max : {0} ~ Min : {1} size : {2}byte", decimal.MaxValue, decimal.MinValue, sizeof(decimal));

            bool m = false;
            Console.WriteLine("bool 형 size : {0}byte", sizeof(bool));

            object obj = null;
            string str = "";
        }
    }
}

주의사항

1. 실수의 변수 선언 및 값 할당시 C#컴파일러는 기본적으로 double형으로 인식을 합니다. 그래서 실수형을 사용시 접미사

   float ( f ), double ( d ), decimal ( m )를 붙여 정확히 사용하여야 합니다.

2. 편의를 위해서 형식이 맞지 않는 값으로 변환을 하였을때 생기는 문제점들 입니다.

   컴파일러에서는 문제를 발생하지 않았지만 결과 값과 같이 데이터 손실로 인해 의도치 않은 버그를 유발하기도 합니다.

            double a = 1.23456789123456d;
            float b = (float)a;
            int c = (int)b;
           
            Console.WriteLine("double : {0}", a);
            Console.WriteLine("float : {0}", b);
            Console.WriteLine("int : {0}", c);