CSharp 연산자

양승준·2025년 3월 26일

Csharp 논리연산자 대입연산자 비교연산자 산술연산자 연산자 증감연산자

CSharp

목록 보기

4/20

연산자

연산자라는 것은 무엇일까? 수학에서의 수학적 연산자란 두 개 이상의 수 또는 수학적 대상 사이의 연산(조작)을 나타내는 기호 또는 명칭을 얘기한다. 그렇다면 프로그래밍적 연산자란 무엇일까? 하나 이상의 값(피연산자)에 대한 특정 연산을 수행하여 결과를 만드는 기호 또는 키워드 라고 검색하면 나와 있다.

수학: 두 개 이상의 수 또는 수학적 대상 사이의 연산(조작)을 나타내는 기호 또는 명칭
프로그래밍: 하나 이상의 값(피연산자)에 대한 특정 연산을 수행하여 결과를 만드는 기호 또는 키워드

위와 같은 글을 보면 알 수 있다.
수학 은 개념과 관계를 정의하는 것에, 반면 프로그래밍 은 명령과 데이터 처리에 목적을 두고 있다. 그래서 이 글에서는 프로그래밍 적 연산자를 사용함으로서 어떻게 명령을 내리고, 데이터를 처리하는지에 대한 것을 정리한다.

연산자들

1. 산술 연산자

연산자	의미	예시	결과
`+`	덧셈	`3 + 2`	`5`
`-`	뺄셈	`5 - 2`	`3`
`*`	곱셈	`3 * 4`	`12`
`/`	나눗셈	`7 / 2`	`3` (정수)
`%`	나머지	`7 % 2`	`1`

⚠ 정수끼리 나누면 소수점은 버려짐.

이렇게 기본적인 산술 기호들이 있는데 덧셈과 뺄셈은 수학 기호하고 똑같지만, 곱셉부터는 다르다. 하지만 사용에 있어 결과는 같다는 것을 알 수 있다.

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int iFirstNum = 10;
            int iSecondNum = 3;
            
            Console.WriteLine("{0} + {1} = {2}", iFirstNum, iSecondNum, iFirstNum + iSecondNum);
            Console.WriteLine("{0} - {1} = {2}", iFirstNum, iSecondNum, iFirstNum - iSecondNum);
            Console.WriteLine("{0} * {1} = {2}", iFirstNum, iSecondNum, iFirstNum * iSecondNum);
            Console.WriteLine("{0} / {1} = {2}", iFirstNum, iSecondNum, iFirstNum / iSecondNum);
            Console.WriteLine("{0} % {1} = {2}", iFirstNum, iSecondNum, iFirstNum % iSecondNum);
        }
    }
}

10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3
10 % 3 = 1

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        float fFirstNum2 = 10.0f;
			float fSecondNum2 = 3.0f;

			
			Console.WriteLine("{0} + {1} = {2}", fFirstNum2, fSecondNum2, fFirstNum2 + fSecondNum2);
			Console.WriteLine("{0} - {1} = {2}", fFirstNum2, fSecondNum2, fFirstNum2 - fSecondNum2);
			Console.WriteLine("{0} * {1} = {2}", fFirstNum2, fSecondNum2, fFirstNum2 * fSecondNum2);
			Console.WriteLine("{0} / {1} = {2}", fFirstNum2, fSecondNum2, fFirstNum2 / fSecondNum2);
			Console.WriteLine("{0} % {1} = {2}", fFirstNum2, fSecondNum2, fFirstNum2 % fSecondNum2);
        }
    }
}

10 + 3 = 13
10 - 3 = 7
10 * 3 = 30
10 / 3 = 3.333333
10 % 3 = 1

이와 같이 출력이 된다. 연산자들 중에 조심해야될 것은 나누기이다. 정수 나누기 연산은 0.1 과 같은 실수 값을 저장할 수 없기에 소수점 값을 버려지고 몫 만 저장된다. 그렇기에 더욱 신경을 써서 사용해주어야된다.

2. 대입 연산자

연산자	의미	예시
`=`	대입	`x = 10`
`+=`	덧셈 후 대입	`x += 5`
`-=`	뺄셈 후 대입	`x -= 3`
`*=`	곱셈 후 대입	`x *= 2`
`/=`	나눗셈 후 대입	`x /= 4`
`%=`	나머지 후 대입	`x %= 3`

대입 연산자이다. 이 글이나 현재 위에 글의 코드를 보다가 보면 대입 연산자가 많이 등장한다. 하지만 기본적인 진짜 대입하는 연산자만 사용했다. 먼저 기본적인 = 대입 연산자은 우측의 처리 값을 좌측의 변수에 넣어준다는 규칙 을 가지고 있다.

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int iFixedNum = 10;
            int iSecondNum = 3;
            
            int numA = iFixedNum;
            int numB = iFixedNum;
            int numC = iFixedNum;
            int numD = iFixedNum;
            int numE = iFixedNum;
            
            numA += iSecondNum; // numA = 10 + iSecondNum 와 같은 기능을 한다.
            numB -= iSecondNum; // numB = 10 - iSecondNum 와 같은 기능을 한다.
            numC *= iSecondNum; // numC = 10 * iSecondNum 와 같은 기능을 한다.
           	numD /= iSecondNum; // numD = 10 / iSecondNum 와 같은 기능을 한다.
            numE %= iSecondNum; // numE = 10 % iSecondNum 와 같은 기능을 한다.
            
            Console.WriteLine("{0} + {1} = {2}", iFirstNum, iSecondNum, numA);
            Console.WriteLine("{0} - {1} = {2}", iFirstNum, iSecondNum, numB);
            Console.WriteLine("{0} * {1} = {2}", iFirstNum, iSecondNum, numC);
            Console.WriteLine("{0} / {1} = {2}", iFirstNum, iSecondNum, numD);
            Console.WriteLine("{0} % {1} = {2}", iFirstNum, iSecondNum, numE);
            
            /*
            위의 대입 연산자와 같은 결과 출력한다.
            Console.WriteLine("{0} + {1} = {2}", iFirstNum, iSecondNum, iFirstNum + iSecondNum);
            Console.WriteLine("{0} - {1} = {2}", iFirstNum, iSecondNum, iFirstNum - iSecondNum);
            Console.WriteLine("{0} * {1} = {2}", iFirstNum, iSecondNum, iFirstNum * iSecondNum);
            Console.WriteLine("{0} / {1} = {2}", iFirstNum, iSecondNum, iFirstNum / iSecondNum);
            Console.WriteLine("{0} % {1} = {2}", iFirstNum, iSecondNum, iFirstNum % iSecondNum);
            */
        }
    }
}

3. 비교 연산자

비교 연산자, 비교할 때 사용하는 연산자이다. 간단해 보이는 이 ==, != 등등의 비교 연산자가 나중에 조건문을 사용하게 되면서 엄청나게 중요하고 많이 사용하게 된다. 이번에는 그런 비교 연산자들이 어떤 것들이 있는지 보고 사용 방법을 정리하겠다.

연산자	의미	예시	결과
`==`	같음	`a == b`	`true/false`
`!=`	다름	`a != b`	`true/false`
`<`	작음	`a < b`	`true/false`
`>`	큼	`a > b`	`true/false`
`<=`	작거나 같음	`a <= b`	`true/false`
`>=`	크거나 같음	`a >= b`	`true/false`

이러한 같음, 다름, 작음, 큼 등등을 어디에다가 사용할까? 간단하게 생각해보면 아이디, 비번을 확인할 때 사용하기도 하고 게임으로 생각하면 공격을 했을 때 나의 공격력으로 적의 체력 보다 내가 입힌 피해가 더 커서 죽는 경우를 체크하는데 사용할 수 도 있을 것이다.

비교 연산자 사용 코드 1

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        string id = "HelloWorld!";
            string pw = "No!Hello";
			
            string inputID = "HelloWorld!";
            string inputPW = "Yes!Hello";
            
            bool equalsID = id == inputID;
            bool equalsPW = pw == inputPW;
            
            Console.WriteLine("= 비교 연산자 사용 출력 결과1 =");
            Console.WriteLine("내 아이디: {0}", id);
            Console.WriteLine("내 비밀번호: {0}", pw);
            
            Console.WriteLine("내가 입력한 아이디: {0}", inputID);
            Console.WriteLine("내가 입력한 비밀번호: {0}", inputPW);
            
            Console.WriteLine("내가 입력한 아이디와 내 아이디가 같은지 여부: {0}", equalsID);
            Console.WriteLine("내가 입력한 비밀번호와 내 비밀번호가 같은지 여부: {0}", equalsPW);
        }
    }
}

= 비교 연산자 사용 출력 결과1 =
내 아이디: HelloWorld!
내 비밀번호: No!Hello
내가 입력한 아이디: HelloWorld!
내가 입력한 비밀번호: Yes!Hello
내가 입력한 아이디와 내 아이디가 같은지 여부: True
내가 입력한 비밀번호와 내 비밀번호가 같은지 여부: False

이런 식으로 내가 아이디, 비밀번호가 내가 입력한 아이디, 비밀번호가 맞는지 확인하는 코드를 작성해서 확인해볼 수도 있다.

비교 연산자 사용 코드 2

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int totalAppleCount = 10;
            int eatAppleCount = 6;

            Console.WriteLine("= 비교 연산자 사용 출력 결과2 =");
            Console.WriteLine("내가 가지고 있는 사과 개수: {0}", totalAppleCount);
            Console.WriteLine("내가 먹은 사과 개수: {0}", eatAppleCount);

            Console.WriteLine("총 사과 {0}, 먹은 사과 {1}, 총 사과 != 먹은 사과 >> {2}", totalAppleCount, eatAppleCount, totalAppleCount != eatAppleCount);
            Console.WriteLine("총 사과 {0}, 먹은 사과 {1}, 총 사과 < 먹은 사과 >> {2}", totalAppleCount, eatAppleCount, totalAppleCount < eatAppleCount);
            Console.WriteLine("총 사과 {0}, 먹은 사과 {1}, 총 사과 > 먹은 사과 >> {2}", totalAppleCount, eatAppleCount, totalAppleCount > eatAppleCount);
            Console.WriteLine("총 사과 {0}, 먹은 사과 {1}, 총 사과 <= 먹은 사과 >> {2}", totalAppleCount, eatAppleCount, totalAppleCount <= eatAppleCount);
            Console.WriteLine("총 사과 {0}, 먹은 사과 {1}, 총 사과 >= 먹은 사과 >> {2}", totalAppleCount, eatAppleCount, totalAppleCount >= eatAppleCount);
        }
    }
}

= 비교 연산자 사용 출력 결과2 =
내가 가지고 있는 사과 개수: 10
내가 먹은 사과 개수: 6
총 사과 10, 먹은 사과 6, 총 사과 != 먹은 사과 >> True
총 사과 10, 먹은 사과 6, 총 사과 < 먹은 사과 >> False
총 사과 10, 먹은 사과 6, 총 사과 > 먹은 사과 >> True
총 사과 10, 먹은 사과 6, 총 사과 <= 먹은 사과 >> False
총 사과 10, 먹은 사과 6, 총 사과 >= 먹은 사과 >> True

이런 식으로 개수 확인용으로 사용한다면 나중에 게임에서는 아이템 개수를 확인해서, 개수가 있다면 사용하게 조건을 줄 수 있고 최대치를 넘었다면 더 이상 못먹게도 할 수 있다.

4. 논리 연산자

연산자	의미	예시
&&	AND (둘 다 참)	a && b
\|\|	OR (하나라도 참)	a \|\| b
!	NOT (부정)	!a

논리 연산자 여러 조건들을 같이 체크할 때 유용하게 사용한다. 내가 치킨을 4개 이상, 6개 이하을 먹을 수 있다. 라는 조건이 있다고 하자. 그럼 우리는 `4 <= 먹을 수 있는 치긴 <= 6` 처럼 딱 생각 되지만 컴퓨터는 하나의 조건은 2개의 비교 대상, 하나의 비교 기호로 참과 거짓을 편별한다. 여기에서는 내가 먹은 치킨 수, 최소 먹을 수 있는 수, 최대 먹을 수 있는 수가 존재한다. 그렇기 때문에 3개의 조건이 있는 것이다. 그럼 비교 연산자도 2개가 필요하다.

대상들
- 내가 먹은 치킨 수
- 최대 먹을 수 있는 수
- 최소 먹을 수 있는 수
비교
- 내가 먹은 치킨 수 <= 최대 먹을 수 있는 수
- 내가 먹은 치킨 수 >= 최소 먹을 수 있는 수

만약 내가 먹은 치킨 수가 5이면?
최대 조건과 최소 조건도 맞은 것이다.

내가 먹은 치킨 수 <= 최대 먹을 수 있는 수 > true
내가 먹은 치킨 수 >= 최소 먹을 수 있는 수 > true

만약 내가 먹은 치킨 수가 7이면?
최대 조건과 최소 조건도 맞은 것이다.

내가 먹은 치킨 수 <= 최대 먹을 수 있는 수 > false
내가 먹은 치킨 수 >= 최소 먹을 수 있는 수 > true

이러한 상황에서 내가 저 범위 안에서 맞는 수만을 먹기를 원한다면 2개의 조건이 True 가 나와야 될 것이다.
그럴 때 사용 할 수 있는 것이 && 의 연산자 기호를 갖은 AND 연산자이다.
AND 연산자는 && 기호 앞뒤로의 조건들이 둘 다 참일 때 참인 결과를 가지고 온다.

상황 A: 내가 먹은 치킨 수 <= 최대 먹을 수 있는 수 > true
상황 B: 내가 먹은 치킨 수 >= 최소 먹을 수 있는 수 > true

상황 A && 상황 B -> true && true -> true

위와 같은 식으로 결과가 나온다.
나머지 || 기호를 갖고 있는 OR 연산자는 두 조건 중에 하나만 맞아도 참, 둘 다 거짓일 때 거짓을,
! 기호를 갖고 있는 NOT 연산자는 기존의 결과를 반전하는 기능을 가지고 있다. 참에다가 ! 사용 시, 반대인 거짓으로 변경된다. 이걸 표로 표현하자면~

&& (AND)

A	B	A && B
T	T	T
T	F	F
F	T	F
F	F	F

`||` (OR)

A	B	A \|\| B
T	T	T
T	F	T
F	T	T
F	F	F

`!` (NOT)

A	!A
T	F
F	T

논리 연산자 사용 코드

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int totalChicken = 10;
            int soldChicken = 6;

            Console.WriteLine("\n= 논리 연산자 사용 출력 결과 =");
            Console.WriteLine("오늘 판매한 치킨 개수 {0}, 오늘 만든 총 치킨 {1}", soldChicken, totalChicken);
            Console.WriteLine("오늘 만든 치킨은 10개이면서 판매한 치킨이 만든 치킨의 50%를 넘었는가? {0}", totalChicken == 10 && ((float)soldChicken / (float)totalChicken) > 0.5f);
            Console.WriteLine("오늘 만든 치킨은 10개이거나 판매한 치킨이 만든 치킨의 50%를 넘었는가? {0}", totalChicken == 10 || ((float)soldChicken / (float)totalChicken) > 0.5f);
            Console.WriteLine("오늘 만든 치킨은 10개도 아니면서 판매한 치킨이 만든 치킨의 50%를 못 넘었는가? {0}", !(totalChicken == 10 && ((float)soldChicken / (float)totalChicken) > 0.5f));
        }
    }
}

= 논리 연산자 사용 출력 결과 =
오늘 판매한 치킨 개수 6, 오늘 만든 총 치킨 10
오늘 만든 치킨은 10개이면서 판매한 치킨이 만든 치킨의 50%를 넘었는가? True
오늘 만든 치킨은 10개이거나 판매한 치킨이 만든 치킨의 50%를 넘었는가? True
오늘 만든 치킨은 10개도 아니면서 판매한 치킨이 만든 치킨의 50%를 못 넘었는가? False

위와 같이 출력이 되었다. 이렇게 && 기호를 갖고 있는 AND 연산자의 사용, || 기호를 갖고 있는 OR 연산자의 사용, ! 기호를 갖고 있는 NOT 연산자의 사용를 보았다. 이런 것들은 나중에 캐릭터를 만들고 게임에서 마법 스킬을 사용하려고 한다는 상황이 았다고 하자. 이 때 캐릭터는 마법을 사용하기 위해서는 마법 지팡이와 마법사 전직을 해야만 사용을 할 수 있다고 한다면 && 로 2가지 조건이 모두 만족 시에만 마법 스킬을 사용하게 할 때 유용하게 사용될 것이다. 이와 같이 무언가를 만들 때는 많은 조건들과 상황들을 잘 만드는 것이 프로그래머의 능력 아닐까? 라는 생각을 갖게 된다.

5. 증감 연산자

연산자	의미	예시	설명
`++`	1 증가	`x++`, `++x`	전위/후위 증가
`--`	1 감소	`x--`, `--x`	전위/후위 감소

증감 연산자, 어떠한 값을 1 증가하거나 감소 시킬 때 사용한다. 이렇게만 설명을 한다면 "흠 쉽겠구만~" 하는 생각이 들 수 도 있다. 하지만 이 것의 사용의 쟁점은 변수의 앞에 사용하느냐, 뒤에 사용하느냐가 가끔은 엄청난 차이를 만들고는 한다. 이건 바로 코드로 보겠다.

증감 연산자 사용 코드 1

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int OneHundredMillion = 1; // 1억이 있다고 가정하자. (그냥 이건 1억이다. 환율 안친다.)

            Console.WriteLine("\n= 증감 연산자 사용 출력 결과 =");
            Console.WriteLine("통장의 잔고: {0}억", OneHundredMillion);
            Console.WriteLine("{0}억 입금", 1);
            Console.WriteLine("입금 후, 통장의 잔고: {0}억", OneHundredMillion++);
            Console.WriteLine("최종 변수안 값: {0}", OneHundredMillion);
        }
    }
}

= 증감 연산자 사용 출력 결과 =
통장의 잔고: 1억
1억 입금
입금 후, 통장의 잔고: 1억
최종 변수안 값: 2

??? 1억을 입금 했는데 결과를 보려고 잔고를 봤는데 1억이라고 찍힌다... 나였으면 눈이 땡글해졌을 것이다. 어떻게 모은 돈인데 하면서 하지만? 최종적으로 값을 정상적으로 2로 되어있다. 무슨 일이 일어난 것일까? 바로!! 증가 연산자의 위치의 문제이다. 증가 또는 감소 연산자는 위치가 제일 중요하다. ++, --를 뒤쪽에 사용한다면 해당 줄의 할 것을 하고 나중에 처리가 된다. 반면 앞쪽에 사용을 하면 처리 되기 전에 연산 처리가 먼저 실행된다. 그렇다면 정상적으로된 코드를 한번 보자면

증감 연산자 사용 코드 2

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int OneHundredMillion = 1; // 1억이 있다고 가정하자. (그냥 이건 1억이다. 환율 안친다.)

            Console.WriteLine("\n= 증감 연산자 사용 출력 결과 =");
            Console.WriteLine("통장의 잔고: {0}억", OneHundredMillion);
            Console.WriteLine("{0}억 입금", 1);
            Console.WriteLine("입금 후, 통장의 잔고: {0}억", ++OneHundredMillion);
            Console.WriteLine("최종 변수안 값: {0}", OneHundredMillion);
        }
    }
}

= 증감 연산자 사용 출력 결과 =
통장의 잔고: 1억
1억 입금
입금 후, 통장의 잔고: 2억
최종 변수안 값: 2

이와 같이 증가 연산자의 위치만 옮겼는데 바로 정상적으로 처리가 되었다. 그렇기 때문에 증감 연산자를 사용할 때는 내가 원하는 값을 만들기 위해서는 위치 확인이 필수다!

증감 연산자 사용 코드 3

using System;
namespace ValueTypeVariable
{
    internal class Program
    {
        static void Main(string[] args)
        {
	        int OneHundredMillion = 1; // 1억이 있다고 가정하자. (그냥 이건 1억이다. 환율 안친다.)

            Console.WriteLine("\n= 증감 연산자 사용 출력 결과 =");
            Console.WriteLine("통장의 잔고: {0}억", OneHundredMillion);
            Console.WriteLine("{0}억 입금", 1);
            Console.WriteLine("입금 후, 통장의 잔고: {0}억", ++OneHundredMillion);
            Console.WriteLine("최종 변수안 값: {0}", OneHundredMillion);
            
            OneHundredMillion = 1;
            Console.WriteLine("현재 값: {0}", OneHundredMillion);
            Console.WriteLine("++OneHundredMillion: {0}", ++OneHundredMillion);
            Console.WriteLine("변경 후 값: {0}", OneHundredMillion);

            Console.WriteLine("현재 값: {0}", OneHundredMillion);
            Console.WriteLine("OneHundredMillion++: {0}", OneHundredMillion++);
            Console.WriteLine("변경 후 값: {0}", OneHundredMillion);

            Console.WriteLine("현재 값: {0}", OneHundredMillion);
            Console.WriteLine("--OneHundredMillion: {0}", --OneHundredMillion);
            Console.WriteLine("변경 후 값: {0}", OneHundredMillion);

            Console.WriteLine("현재 값: {0}", OneHundredMillion);
            Console.WriteLine("OneHundredMillion--: {0}", OneHundredMillion--);
            Console.WriteLine("변경 후 값: {0}", OneHundredMillion);
        }
    }
}

= 증감 연산자 사용 출력 결과 =
통장의 잔고: 1억
1억 입금
입금 후, 통장의 잔고: 2억
최종 변수안 값: 2
현재 값: 1
++OneHundredMillion: 2
변경 후 값: 2
현재 값: 2
OneHundredMillion++: 2
변경 후 값: 3
현재 값: 3
--OneHundredMillion: 2
변경 후 값: 2
현재 값: 2
OneHundredMillion--: 2
변경 후 값: 1

이상으로 해당 포스팅을 마침다. 원래는 삼항 연산자와 비트 연산자를 더 하려고 했지만, 나중에 조건문 정리하면서 삼항 연산자 정리를 같이하고 1의 보수, 2의 보수 정리하면서 비트 연산자 정리를 진행하겠다.

양승준

지모창말, 미모창.

이전 포스트

CSharp 변수

다음 포스트

CSharp 연산자

CSharp

연산자

연산자들

1. 산술 연산자

2. 대입 연산자

3. 비교 연산자

비교 연산자 사용 코드 1

비교 연산자 사용 코드 2

4. 논리 연산자

&& (AND)

`||` (OR)

`!` (NOT)

논리 연산자 사용 코드

5. 증감 연산자

증감 연산자 사용 코드 1

증감 연산자 사용 코드 2

증감 연산자 사용 코드 3

CSharp 변수

CSharp 입력하기!(Read & ReadLine)

0개의 댓글

CSharp 연산자

CSharp

연산자

연산자들

1. 산술 연산자

2. 대입 연산자

3. 비교 연산자

비교 연산자 사용 코드 1

비교 연산자 사용 코드 2

4. 논리 연산자

&& (AND)

|| (OR)

! (NOT)

논리 연산자 사용 코드

5. 증감 연산자

증감 연산자 사용 코드 1

증감 연산자 사용 코드 2

증감 연산자 사용 코드 3

CSharp 변수

CSharp 입력하기!(Read & ReadLine)

0개의 댓글

`||` (OR)

`!` (NOT)