사용자로부터 얻은 정보를 변수에 저장하기

• 2/17/2025
• 60 minutes to read

프로그램을 실행할 때마다 서로 다른 값을 입력받으려면 콘솔에서 입력한 값을 변수에 저장할 수 있어야 합니다. 키보드로 입력을 받고 모니터로 출력하는 일반적인 작업을 표준 입출력(standard input/output) 이라고 합니다.

> // Console.ReadLine()으로 콘솔(터미널)로부터 데이터 입력 받기 

1. 데이터 입력 관련 메서드

C#에서는 Console 클래스를 사용하여 사용자로부터 데이터를 입력받고 이를 콘솔 화면에 출력할 수 있습니다. 지금까지 Console.Write() 또는 Console.WriteLine() 메서드를 사용하여 데이터를 출력했듯이, 입력을 받을 때는 다음과 같은 메서드를 활용할 수 있습니다.

주요 입력 메서드

• Console.ReadLine()
  • 콘솔에서 한 줄을 입력받습니다. 사용자가 엔터 키를 누를 때까지 대기합니다.
• Console.Read()
  • 콘솔에서 한 문자를 정수 값으로 입력받습니다.
• Console.ReadKey()
  • 사용자가 입력한 한 개의 문자 또는 기능 키를 가져옵니다.

이 중 가장 많이 사용하는 Console.ReadLine() 메서드는 문자열(String) 데이터를 반환합니다. 사용자가 엔터를 누를 때까지 프로그램 실행이 일시적으로 멈추며, 입력한 문자열이 반환됩니다.

Console.ReadLine() 메서드 사용하기

다음 코드는 실행하면 콘솔 화면에서 대기하는 효과를 가집니다. 엔터 키를 입력하면 다음으로 넘어갑니다. 참고로, Console.ReadLine()과 같은 입력 메서드는 C# Interactive에서는 사용이 되지 않습니다. 직접 프로젝트 만들고 연습해야 합니다.

코드: ReadLineDemo.cs

using System;

class ReadLineDemo
{
    static void Main()
    {
        Console.ReadLine(); // <- 이 시점에서 대기하는 효과 
    }
}

Console.ReadLine() 메서드는 다음 그림과 같이 실행하면 콘솔로부터 입력을 대기 합니다. 엔터를 입력하면 Console.ReadLine() 메서드가 실행되고 프로그램이 종료됩니다.

그림: ReadLine() 메서드 실행 결과

콘솔로부터 입력된 값을 그대로 출력하기

다음과 같이 코드를 작성한 후 Ctrl +F5로 실행해 보세요. 콘솔에서 아무 문자열이나 입력한 후 엔터키를 누르면 그 값이 그대로 출력됩니다.

코드: ConsoleReadLineDemo.cs

using System;

class ConsoleReadLineDemo
{
    static void Main()
    {
        //[1] 콘솔로 입력받은 문자열을 그대로 콘솔에 출력하기 
        Console.WriteLine(Console.ReadLine());
    }
}

문자열 입력 후 엔터 키를 누르세요.
문자열 입력 후 엔터 키를 누르세요.

프로그램을 실행 후 키보드로부터 한 줄을 입력 후 엔터를 치면 입력한 문자열이 그대로 출력됩니다. "안녕하세요."와 같은 문자열을 입력하면 이 값을 입력 받아서 Console.WriteLine() 메서드를 통해서 다시 입력한 값을 출력할 수 있습니다.

그림: ReadLine() 메서드로 입력받은 문자열을 바로 출력하기

using System;

class InputName
{
    static void Main()
    {
        //[1] 콘솔에 "이름을 입력하시오 =>" 출력 
        Console.Write("이름을 입력하시오 => ");
        //[2] 콘솔로부터 문자열을 입력받아 name 변수에 저장
        string name = Console.ReadLine();
        //[3] name 변수의 값을 {0}에 출력
        Console.WriteLine("안녕하세요. {0}님.", name); 
    }
}

이름을 입력하시오 => 박용준
안녕하세요. 박용준님.

# 공백을 기준으로 두 개의 문자열 입력
x, y = input("두 개의 문자열 입력: ").split()

print(x) # Hello
print(y) # World

두 개의 문자열 입력: Hello World
Hello
World

#include <iostream>
#include <string>

using namespace std;

int main(void)
{
    string name;

    cout << "이름: ";

    cin >> name;

    cout << "안녕하세요? " << name << "님!!!" << endl;

    return 0;
}

이름: 박용준
안녕하세요? 박용준님!!!

2. Console.Read() 메서드로 문자 하나를 정수로 입력 받기

Console.Read() 메서드를 사용하면 키보드로부터 문자 하나를 입력 받을 수 있습니다. 입력 값은 우리가 입력한 값과 다르게 문자에 해당하는 정수로 반환됩니다. 정수에 해당하는 문자를 출력하려면 Convert.ToChar() 메서드를 사용합니다. Convert 클래스에 대해서는 잠시 후에 다시 살펴보겠습니다.

코드: ConsoleReadDemo.cs

using System;

class ConsoleReadDemo
{
    static void Main()
    {
        //[1] 콘솔로부터 문자 하나를 입력 후 엔터키를 누릅니다. 
        int x = Console.Read();

        //[2] 대문자 'A'가 입력되면 'A'에 해당하는 정수 값인 65가 출력됩니다.
        Console.WriteLine(x);

        //[3] x가 65면 정수 65에 해당하는 유니코드 문자인 A가 출력됩니다. 
        Console.WriteLine(Convert.ToChar(x)); 
    }
}

A [Enter]
65
A

Console.Read() 메서드로 화면으로부터 문자 하나를 입력 받습니다. 이렇게 입력된 문자는 정수형 변수로 반환됩니다. 만약 'A'를 입력하면 아스키코드에 의해서 65가 저장됩니다. 다시 65에 해당하는 문자를 표현하려면 Convert.ToChar() 메서드로 묶어주면 됩니다.

형식 변환(Type Conversion)

Console.ReadLine() 메서드를 사용하여 입력받은 데이터는 문자열(String) 형식입니다. 그러나 정수(Integer) 또는 실수(Float)와 같은 데이터 형식으로 사용하려면, 입력된 문자열을 원하는 형식으로 변환해야 합니다.

데이터 형식 변환은 같은 형식끼리는 별도의 변환 없이 그대로 대입할 수 있습니다.

예제: 동일한 데이터 형식 간의 대입

int number1 = 1234; // 정수 1234를 number1 변수에 저장
int number2 = number1; // number1의 값을 number2에 그대로 저장
Console.WriteLine(number2); // 1234 출력

형식 변환의 종류

형식 변환은 크게 암시적(Implicit) 변환과 명시적(Explicit) 변환으로 나뉩니다.

암시적 변환 (Implicit Conversion)

• 컴파일러가 자동으로 변환해 주는 형식 변환
• 작은 크기의 데이터 타입에서 더 큰 크기의 데이터 타입으로 변환 가능
• 데이터 손실이 발생하지 않음

명시적 변환 (Explicit Conversion)

• 프로그래머가 직접 변환을 지정해야 하는 형식 변환
• 큰 크기의 데이터 타입을 작은 크기의 데이터 타입으로 변환할 때 사용
• 데이터 손실이 발생할 가능성이 있음

1. 암시적(Implicit) 형 변환

예를 들어, int(4바이트) 타입의 데이터를 long(8바이트) 타입 변수에 저장할 때는 자동으로 변환됩니다.

예제: 암시적 형 변환

int number1 = 1234; // 정수 1234를 number1 변수에 저장
long number2 = number1; // int → long 변환 (자동)
Console.WriteLine(number2); // 1234 출력

int보다 크기가 더 큰 long 형식에는 int 값을 그대로 저장할 수 있기 때문에 별도의 변환 없이 자동 변환이 가능합니다.

2. 명시적(Explicit) 형 변환

반대로, long(8바이트) 타입의 데이터를 int(4바이트) 타입 변수에 저장하려면 명시적으로 변환(casting) 해야 합니다. 이 과정에서 데이터 손실이 발생할 가능성이 있으므로 주의해야 합니다.

예제: 명시적 형 변환

long number1 = 1234; // 정수 1234를 long 형식 변수에 저장
int number2 = (int)number1; // (int) 형변환을 통해 long → int 변환
Console.WriteLine(number2); // 1234 출력

(int)를 사용하여 명시적 변환(casting) 을 수행해야 합니다. 만약 long 값이 int의 범위를 초과하면 잘못된 값이 저장될 수도 있습니다.

잘못된 형식 변환

이번에는 long 형식의 변수의 값을 int 형식의 변수에 저장하면 어떻게 될까요? 먼저 에러는 나지 않지만 잘못된 값이 저장되는 경우를 살펴보겠습니다. 참고로 소스에서 변수명은 L의 소문자인 l과 I의 소문자인 i를 사용하였습니다.

코드: TypeConversionError.cs

using System;

class TypeConversionError
{
    static void Main()
    {
        long l = long.MaxValue; //[1] long 형식 변수의 가장 큰 값을 l 변수에 저장
        Console.WriteLine($"l의 값: {l}");
        int i = (int)l; //[2] l 변수의 값을 int 형식으로 형식 변환하여 i 변수에 저장
        Console.WriteLine($"i의 값: {i}");
    }
}

l의 값: 9223372036854775807
i의 값: -1

변수 또는 리터럴 앞에 괄호와 데이터 형식 키워드를 사용하는 (int)와 같은 표현식을 사용하여 long 형식의 변수를 int 형식의 변수로 변환할 수 있습니다. 다만, 이 때 주의할 것은 int 형식 변수의 크기를 벗어나는 데이터를 저장하게 되면 잘못된 데이터가 저장될 수 있으니 사용에 주의해야 합니다.

int 형식의 변수를 byte 형식의 변수로 형식 변환(Casting)

정수 형식을 담을 수 있는 int 형식의 변수의 값을 0~255까지만 담을 수 있는 정수 형식 변수인 byte에 담을 때에는 (byte)를 붙여서 담을 수 있습니다. 만약, 255 이상의 값을 담으면 잘못된 데이터가 저장되니 주의해야 합니다. 다음은 int를 byte로 변환하는 예입니다.

코드: IntToByte.cs

using System;

class IntToByte
{
    static void Main()
    {
        int x = 255;

        byte y = (byte)x; // byte 형식은 0에서 255까지 저장 가능

        Console.WriteLine($"{x} -> {y}"); // 보간된 문자열을 사용하여 x와 y의 값 출력
    }
}

255 -> 255

3.3. Convert 클래스를 사용하여 형식 변환하기

C#에서는 데이터 형식을 변환하는 방법으로 괄호 연산자((type))를 이용한 형 변환뿐만 아니라, Convert 클래스를 사용할 수도 있습니다. Convert 클래스는 다양한 데이터 형식 변환을 지원하는 메서드를 제공합니다.

주요 Convert 클래스 메서드

Convert 클래스 사용 예시

아래는 Convert 클래스를 활용하여 데이터 형식을 변환하는 코드 예제입니다.

이처럼 Convert 클래스는 다양한 데이터 형식 변환을 쉽게 처리할 수 있도록 도와줍니다. 형식 변환이 필요한 경우, 형 변환 연산자와 Convert 클래스 메서드 중 상황에 맞는 방법을 선택하여 사용하면 됩니다.

Convert 클래스 사용하기

이번에는 형식을 변환시켜주는 Convert 클래스를 사용해 보겠습니다. 다음 내용을 Visual Studio의 소스 코드 편집 창에 입력하세요.

코드: TypeConversion.cs

using System;

class TypeConversion
{
    static void Main()
    {
        double d = 12.34;
        int i = 1234;

        //[1] double > int: 묵시적(암묵적, 암시적) 형식 변환
        d = i; // 큰 그릇에 작은 그릇의 값이 저장
        Console.WriteLine(d); // 1234

        //[2] 작은 형식 <= 큰 형식: 명시적인 형식 변환 필요
        d = 12.34;
        i = (int)d; // () 캐스트 연산자 사용: 정수형 데이만 저장
        Console.WriteLine(i); // 12

        //[3] 다른 형식간의 변환: Convert 클래스
        string s = "";
        s = Convert.ToString(d); // Convert.ToInt32(), Convert.ToDouble()
        Console.WriteLine(s); // "12.34"
    }
}

1234
12
12.34

Convert.ToInt32()는 int.Parse() 메서드로 Convert.ToDouble()은 double.Parse() 메서드로 대체해서 사용할 수도 있습니다. 나중에 제어문 파트를 학습하고나면 int.TryParse(), double.TryParse()와 같은 메서드를 사용하여 좀 더 안전하게 데이터를 변환할 수도 있습니다. 지금은 현재 예제에만 집중해도 됩니다.

정수 형식으로 형식 변환하는 3가지 방법

참고로, 정수 모양의 문자열을 정수 형식으로 변환하는 3가지 방법은 다음 샘플코드와 같습니다. 코드의 GetType() 메서드는 바로 다음 절에서 설명됩니다.

코드: IntParse.cs

> string strNumber = "1234";
> int number1 = Convert.ToInt32(strNumber);
> $"{number1} - {number1.GetType()}"
"1234 - System.Int32"
> int number2 = int.Parse(strNumber);
> $"{number2} - {number2.GetType()}"
"1234 - System.Int32"
> int number3 = Int32.Parse(strNumber);
> $"{number3} - {number3.GetType()}"
"1234 - System.Int32"

참고: GetType() 메서드로 모든 변수의 데이터 형식을 알아내기

.NET에서 제공하는 GetType() 메서드는 모든 값의 데이터 형식을 알려줍니다.

코드: GetTypeDemo.cs

// GetType() 메서드: 모든 값의 데이터 형식을 반환
using System;

class GetTypeDemo
{
    static void Main()
    {
        int i = 1234;               // 정수
        string s = "안녕하세요.";    // 문자열
        char c = 'A';               // 문자
        double d = 3.14;            // 실수
        object o = new Object();    // 개체: 개체 생성하는 구문

        Console.WriteLine(i.GetType()); // System.Int32
        Console.WriteLine(s.GetType()); // System.String
        Console.WriteLine(c.GetType()); // System.Char
        Console.WriteLine(d.GetType()); // System.Double
        Console.WriteLine(o.GetType()); // System.Object
    }
}

System.Int32
System.String
System.Char
System.Double
System.Object

모든 변수에 GetType() 메서드를 요청하면 해당 변수의 .NET 데이터 형식을 알려줍니다.

object o = new Object(); 형태의 코드는 모든 데이터 형식을 담을 수 있는 그릇을 만드는 작업인데요. 개체를 생성하는 작업입니다. 이러한 형태는 앞으로 계속 알아갈 테니 지금은 GetType() 메서드의 결과에 집중하면 됩니다.

GetTypeDemo.py

>>> i = 1234
>>> s = "안녕하세요."
>>> f = 3.14
>>> print(type(i)) # <class 'int'>
<class 'int'>
>>> print(type(s)) # <class 'str'>
<class 'str'>
>>> print(type(f)) # <class 'float'>
<class 'float'>
>>>

using System;

class ReadLineInteger
{
    static void Main()
    {
        Console.Write("정수를 입력하세요: ");
        string input = Console.ReadLine(); // "10"을 입력한다면
        int number = Convert.ToInt32(input); // "10"을 정수 10으로 변환
        Console.WriteLine($"{number}-{number.GetType()}"); // 10-System.Int32
    }
}

정수를 입력하세요: 10
10-System.Int32

> Convert.ToInt32("Hello")
입력 문자열의 형식이 잘못되었습니다.

#include <stdio.h>
#include <stdlib.h>

int main() {
    printf("정수를 입력하세요: ");
    char input[10];
    fgets(input, sizeof(input), stdin); // "10"을 입력한다면
    int number = atoi(input); // "10"을 정수 10으로 변환
    printf("%d-int\n", number); // 10-int
    return 0;
}

정수를 입력하세요: 10
10-int

> atoi("Hello")
0

import java.util.Scanner;

public class ReadLineInteger {
    public static void main(String[] args) {
        System.out.print("정수를 입력하세요: ");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.nextLine(); // "10"을 입력한다면
        int number = Integer.parseInt(input); // "10"을 정수 10으로 변환
        System.out.println(number + "-" + number.getClass().getName()); // 10-java.lang.Integer
    }
}

정수를 입력하세요: 10
10-java.lang.Integer

> Integer.parseInt("Hello")
Exception in thread "main" java.lang.NumberFormatException: For input string: "Hello"

print("정수를 입력하세요: ", end="")
input_str = input()  # "10"을 입력한다면
number = int(input_str)  # "10"을 정수 10으로 변환
print(f"{number}-{type(number)}")  # 10-<class 'int'>

정수를 입력하세요: 10
10-<class 'int'>

> int("Hello")
ValueError: invalid literal for int() with base 10: 'Hello'

using System;

class ReadLineRealNumber
{
    static void Main()
    {
        Console.Write("실수를 입력하세요: ");
        string input = Console.ReadLine(); // "3.14"를 입력한다면 
        double PI = Convert.ToDouble(input); // "3.14"를 3.14로 변경
        Console.WriteLine(PI); // 3.14
    }
}

실수를 입력하세요: 3.14
3.14

#include <stdio.h>

int main() {
    double PI;
    printf("실수를 입력하세요: ");
    scanf("%lf", &PI); // "3.14"를 입력한다면 3.14로 변경
    printf("%lf\n", PI); // 3.14
    return 0;
}

실수를 입력하세요: 3.14
3.14

import java.util.Scanner;

public class ReadLineRealNumber {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("실수를 입력하세요: ");
        String input = scanner.nextLine(); // "3.14"를 입력한다면 
        double PI = Double.parseDouble(input); // "3.14"를 3.14로 변경
        System.out.println(PI); // 3.14
    }
}

실수를 입력하세요: 3.14
3.14

input_str = input("실수를 입력하세요: ") # "3.14"를 입력한다면
PI = float(input_str) # "3.14"를 3.14로 변경
print(PI) # 3.14

실수를 입력하세요: 3.14
3.14

const readline = require("readline");
const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question("실수를 입력하세요: ", function(input) {
  const PI = parseFloat(input); // "3.14"를 입력한다면 3.14로 변경
  console.log(PI); // 3.14
  rl.close();
});

실수를 입력하세요: 3.14
3.14

#include <iostream>

int main() {
    double PI;
    std::cout << "실수를 입력하세요: ";
    std::cin >> PI; // "3.14"를 입력한다면 3.14로 변경
    std::cout << PI << std::endl; // 3.14
    return 0;
}

실수를 입력하세요: 3.14
3.14

package main

import (
	"fmt"
	"strconv"
)

func main() {
	var input string
	fmt.Print("실수를 입력하세요: ")
	fmt.Scan(&input) // "3.14"를 입력한다면
	PI, _ := strconv.ParseFloat(input, 64) // "3.14"를 3.14로 변경
	fmt.Println(PI) // 3.14
}

실수를 입력하세요: 3.14
3.14

use std::io;

fn main() {
    let mut input = String::new();
    println!("실수를 입력하세요: ");
    io::stdin()
        .read_line(&mut input)
        .expect("Failed to read line");

    let PI: f64 = input.trim().parse().expect("Please enter a number!");
    println!("{}", PI); // 3.14
}

실수를 입력하세요: 
3.14
3.14

import * as readline from "readline";

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

rl.question("실수를 입력하세요: ", function(input) {
  const PI: number = parseFloat(input); // "3.14"를 입력한다면 3.14로 변경
  console.log(PI); // 3.14
  rl.close();
});

실수를 입력하세요: 3.14
3.14

import java.util.Scanner

fun main() {
    val scanner = Scanner(System.`in`)
    print("실수를 입력하세요: ")
    val input = scanner.nextLine() // "3.14"를 입력한다면
    val PI = input.toDouble() // "3.14"를 3.14로 변경
    println(PI) // 3.14
}

실수를 입력하세요: 3.14
3.14

입력받은 문자열을 문자로 변환해 출력하기

문자열 및 숫자 이외에도 문자 하나만 입력받을 수도 있습니다. 이번에는 콘솔로부터 문자를 입력받는 방법을 살펴보겠습니다.

코드: ReadLineCharacter.cs

using System;

class ReadLineCharacter
{
    static void Main()
    {
        Console.Write("문자를 입력하세요: ");
        string input = Console.ReadLine(); // "가"를 입력하면 
        char c = Convert.ToChar(input); // "가"를 '가'로 변환
        Console.WriteLine(c); // '가'
    }
}

문자를 입력하세요: 가
가

이진수 다루기

우리가 평소에 사용하는 숫자 체계는 십진수를 사용합니다. 컴퓨터에서는 이진수를 사용하죠. 그래서 컴퓨터가 숫자를 인식하게 하려면 십진수를 이진수로 변환해줘야 합니다. C#에서는 컴퓨터에서 사용하는 숫자 체계인 이진수를 표현하려면 다음과 같은 방식을 사용할 수 있습니다.

Convert.ToString(<숫자>, 2)

Convert 클래스의 ToString() 메서드는 특정 숫자의 값을 문자열로 변환시키는 기능을 제공합니다. 만약, 정수의 값을 이진수 문자열로 얻고자할 때에는 Convert.ToString(정수, 2) 형태로 2번째 옵션으로 이진수를 나타내는 2를 지정하면 됩니다.

> Convert.ToString(10, 2)
"1010"
> Convert.ToString(5, 2)
"101"

이때 이진수의 결괏값이 0010이라면 앞에 00이 생략된 10까지만 출력됩니다. 그래서 보통 비트 연산식을 이해하기 편하게 8자리를 잡고 00000010 형태로 이진수로 출력하고자 할 때에는 Convert.ToString() 메서드 뒤에 한번 더 PadLeft() 메서드를 사용해서 8칸을 기준으로 이진수 문자열을 출력하되 앞 부분은 0으로 채워주게 할 수 있습니다. 이 내용은 하나의 트릭이기에 이진수 표현할 때에만 사용합니다.

Convert.ToString(<숫자>, 2).PadLeft(8, '0');

> Convert.ToString(5, 2).PadLeft(4, '0')
"0101"

정수를 이진수 문자열로 표현하기

정수를 이진수 문자열로 표현하는 내용을 살펴보겠습니다.

코드: BinaryString.cs

// 정수를 이진수 문자열로 표현하기 
using System;

class BinaryString
{
    static void Main()
    {
        byte x = 10; // 0000 1010

        // x를 2진수로 표현하되, 8자리로 하고 앞부분은 모두 0으로 채운다
        Console.WriteLine(
            $"십진수: {x} -> 이진수: {Convert.ToString(x, 2).PadLeft(8, '0')}");
    }
}

십진수: 10 -> 이진수: 00001010

위 소스와 같이 정수를 이진수로 표현하는 공식과 같은 코드인 Convert.ToString().PadLeft()의 사용법을 꼭 익혀두세요.

참고: 진법 변환

10진수를 2진수로 또는 2진수를 10진수로 변환시키는 것을 진법 변환이라고 하는데 C#에서는 Covert 클래스의 ToString() 메서드와 ToInt32() 메서드를 사용하여 변환이 가능합니다. 다음 코드는 참고용으로 살펴보세요.

코드: RadixTransformation.cs

using System;

/// <summary>
/// 진법변환
/// </summary>
class RadixTransformation
{
    static void Main()
    {
        // 10진수 10을 2진수로 변경하면 1010
        Console.WriteLine(
            $"십진수 10을 이진수로 변경: {Convert.ToString(10, 2)}"); // 8421 => 1010

        // 2진수 1010을 10진수로 변경하면 10
        Console.WriteLine(
            $"이진수 1010을 십진수로 변경: {Convert.ToInt32("1010", 2)}"); // 10
    }
}

십진수 10을 이진수로 변경: 1010
이진수 1010을 십진수로 변경: 10

참고로, 클래스 앞에 <summary> 코드 블록은 /// 기호를 사용하여 주석 기능과 추가적인 설명 기능을 함께 제공하는 XML 문서 주석입니다. 이러한 문서 주석을 사용하면 해당 클래스에 대한 설명을 붙이는 역할과 나중에 필요하면 클래스 설명서를 HTML과 같은 문서로 자동화해주는 도구에서 여기에 기록된 문구가 사용됩니다.

이진수 리터럴(Binary Literal)

정수 앞에 숫자 0과 영문자 b를 붙이는 0b 또는 0B 접두사를 붙여서 특별한 과정없이 바로 이진수로 표현할 수 있습니다. 0b0010 처럼 표현하면 이진수 0010이 됩니다. 0b 접두사를 붙여서 이진수를 직접 코드로 표현하는 방법인 이진수 리터럴을 코드로 살펴보겠습니다.

코드: BinaryLiteral.cs

> //[?] 바이너리 리터럴(Binary Literal)
> // 0b 또는 0B로 시작하는 정수 리터럴은 이진수 리터럴
> byte b1 = 0b0010; // 이진수 0010 -> 십진수 2 
> byte b2 = 0B1100; // 이진수 1100 -> 십진수 12
> 
> // 컴퓨터에서는 자동으로 십진수 단위로 처리함
> $"10진수: {b1}"
"10진수: 2"
> $"10진수: {b2}"
"10진수: 12"

프로그램 소스 코드에서는 기본적으로 10진수 단위로 자료가 처리됩니다. 하지만, 컴퓨터가 사용하는 2진수를 표현할 때에는 0b와 0B 접두사를 두고 이진수 리터럴을 표현합니다.

언더스코어(_) 문자로 숫자 구분하기

현실 세계에서의 100만을 의미하는 숫자는 1,000,000 형태로 3자리마다 콤마로 구분하여 쉽게 구분할 수 있게 해주는데요. 프로그램 소스 코드에서는 콤마 기호를 사용할 수 없는 대신에 밑줄 문자인 언더스코어(_) 문자를 사용하여 구분합니다.

이진수, 십진수, 16진수 등을 표현할 때 언더스코어(_) 문자를 사용하여 숫자를 구분할 수 있습니다. 언더스코어 문자의 개수는 한 개 이상(또는 여러 개) 사용할 수 있습니다. 긴 숫자를 표현할 때 숫자 구분자를 두게되면 가독성이 좋아집니다. 숫자 구분자를 사용해 보겠습니다.

코드: DigitSeparatorDemo.cs

> int bin = 0b0001_0001; // 0001 0001 
> bin
17
> 
> int dec = 1_000_000; // 1,000,000
> dec
1000000
> 
> int hex = 0xA0_B0_C0; // A0 B0 C0
> hex
10531008

0b 접두사는 이진수 리터럴을 나타냅니다. 현실 세계에서의 1,000,000과 같은 구분자가 있는 숫자는 C#에서는 1_000_000와 같이 표현할 수 있습니다. 0x를 접두사로 붙여서 16진수를 표현할 수 있는데 16진수도 언더스코어 문자를 구분자로 둘 수 있습니다.

var 키워드로 암시적으로 형식화된 로컬 변수 만들기

제목이 다소 어렵게 느껴질 수 있지만, 개념은 간단합니다.
변수를 선언할 때 int, string 등의 데이터 형식을 명시적으로 지정하는 대신, var 키워드를 사용하면 입력된 값에 따라 자동으로 형식이 결정됩니다.

C#에서 var는 강력한 형식으로, C# 컴파일러가 해당 변수에 저장되는 값을 기반으로 적절한 데이터 형식을 자동으로 추론합니다.
이러한 기능을 형식 추론(Type Inference) 이라고 합니다.

> int number = 1234; // 명시적으로 형식화된(Explicit Typing)
> var number = 1234; // 암시적으로 형식화된(Implicit Typing)

이쯤되면 명시적과 암시적이 구분이 되나요?

var 키워드로 변수 선언하기

이번에는 var 키워드로 변수를 선언하고 초기화하는 방법을 살펴보겠습니다.

코드: Var.cs

//[?] var 키워드: 암시적으로 형식화된 로컬 변수
using System;

class Var
{
    static void Main()
    {
        var name = "C#"; // string 형식으로 변환해줌
        Console.WriteLine(name); // C#

        var version = 13.0; // double 형식으로 변환해줌
        Console.WriteLine("{0:0.0}", version); // 12.0
    }
}

C#
13.0

var 키워드로 선언된 변수에 문자열이 들어오면 자동으로 string 형식으로 선언됩니다. 마찬가지로 실수형 데이터가 저장되면 double 형식의 변수가 만들어집니다.

var 키워드로 선언된 변수의 데이터 형식 알아내기

다음 샘플 코드처럼 모든 변수에 GetType() 메서드를 요청하면 해당 변수의 데이터 형식을 알려줍니다.

코드: TypeAssertion.cs

> var number = 1234; // int number;
> number.GetType()
[System.Int32]
> var message = "안녕하세요."; // string message;
> message.GetType()
[System.String]

참고: var와 dynamic 키워드

자바스크립트와 같은 다른 프로그래밍 언어를 알고 있을 때에는 var 키워드가 모든 값을 담고 있어서 C#도 동일하다고 많이 오해를 하는데, C#의 var 키워드는 프로그램 소스 코드 작성의 편의성을 위해 만들어진 키워드이지 모든 값을 다 담을 수 있는 키워드가 아닙니다. 참고로, 자바스크립트의 var에 해당하는 C#의 키워드는 dynamic이 있습니다. dynamic은 나중에 설명합니다.

Console.ReadLine() 메서드의 입력값을 var로 선언한 변수로 받기

콘솔에 사용자로부터 입력되는 값을 var로 선언된 변수에 담아서 사용해 보는 예제를 만들어 봅시다.

코드: VarInput.cs

using System;

class VarInput
{
    static void Main()
    {
        // 문자열 입력 받기
        var s = Console.ReadLine();

        // 문자 하나 입력 받기
        var c = Convert.ToChar(Console.Read());

        // 입력받은 값과 형식 출력하기 
        Console.WriteLine($"{s}: {s.GetType()}, {c}: {c.GetType()}"); 
    }
}

Hello 입력 후 엔터 
C 입력 후 엔터 
Hello: System.String, C: System.Char

Console.ReadLine() 메서드의 반환값은 string 형식인 걸 알기에 s 변수는 자동으로 string 형식의 변수가 됩니다. 마찬가지로 Convert.ToChar() 메서드의 반환값은 char 형식이기에 c 변수의 형식은 자동으로 char 형식이 됩니다.

참고: C++ auto 키워드로 타입 추론

코드: TypeInference.cpp

#include <iostream>
#include <typeinfo>

using namespace std;

int main(void)
{
    auto num1 = 1234;
    auto num2 = 3.14;

    cout << num1 << endl;
    cout << typeid(num1).name() << endl;
    cout << num2 << endl;
    cout << typeid(num2).name() << endl;

    return 0;
}

1234
int
3.14
double

참고: 키보드 키 값 입력받기

다음 코드는 Console.ReadKey() 메서드를 사용하여 키보드로부터 입력된 키값을 알아내는 코드입니다. ConsoleKeyInfo 구조체와 ConsoleKey 열거형을 사용했는데요. 구조체와 열거형에 대한 내용은 뒤에서 각각의 챕터에서 자세히 다루겠지만, 현재 코드는 현재 시점에서는 한번 작성 후 실행해보는 정도로 보고 넘어가면 됩니다.

코드: KeyboardInput.cs

using System;

class KeyboardInput
{
    static void Main()
    {
        Console.WriteLine("아무키나 누르세요.");
        // 키보드 키 값 입력
        ConsoleKeyInfo cki = Console.ReadKey(true);
        Console.WriteLine("{0}", cki.Key); // 키
        Console.WriteLine("{0}", cki.KeyChar); // 유니코드
        Console.WriteLine("{0}", cki.Modifiers); // Ctrl, Shift, Alt 조합
        if (cki.Key == ConsoleKey.Q)
        {
            Console.WriteLine("Q를 입력하셨군요...");
        }
    }
}

아무키나 누르세요.
Q
Q
Shift
Q를 입력하셨군요...

위 실행 결과는 Shift 버튼과 Q를 함께 눌렀을 때의 결과입니다.

변수의 기본 값을 default 키워드로 설정하기

변수를 선언하고 초기화할 때에는 해당 변수의 데이터 형식으로 초기화하면 됩니다. 만약, C#에서 기본으로 제공하는 값으로 초기화할 때에는 default 키워드를 할당해주면 됩니다.

코드: VariableDefault.cs

> int i = default;
> double d = default;
> char c = default;
> string s = default;
> $"[{i}], [{d}], [{c}], [{s}]"
"[0], [0], [\0], []"
> $"[{i}], [{d}], [{c == Char.MinValue}], [{s == null}]"
"[0], [0], [True], [True]"

숫자 데이터 형식은 0으로 char는 '\0'을 string은 null을 기본 값으로 가집니다.

default 키워드로 C# 형식의 기본값 가져오기

특정 형식의 기본값을 반환해주는 키워드가 default입니다. default(T) 형태로도 사용하며 T 자리에는 특정 형식이 들어오는데 이를 기본 식(Default Expression)이라고 합니다. 이를 사용하면 int, bool, string 등의 기본값을 알 수 있습니다. 코드 상의 StringBuilder는 나중에 배울 내용이지만 일단은 지금은 코드를 작성 후 실행해봅니다.

코드: DefaultExpression.cs

> int intDefault = default(int); // int 형식의 기본값
> intDefault
0
> 
> bool boolDefault = default(bool); // bool 형식의 기본값
> boolDefault
false
> 
> string strDefault = default(string); // string 형식의 기본값
> strDefault
null
> 
> using System.Text;
> StringBuilder sbDefault =
.     default(StringBuilder); // StringBuilder 클래스의 기본값
> sbDefault
null

위 실행 결과처럼 특정 형식이 가지는 기본값은 default 키워드 또는 default(T) 형태를 통해서 알 수 있습니다. 최근에 박용준 강사는 default(T) 대신에 짧은 모양인 default로만 사용합니다.

참고: 튜플 리터럴

C#에서는 튜플 리터럴(Tuple Literal)을 제공합니다. 튜플 리터럴에 대해선 뒤에서 자세히 다루겠지만 미리 살펴보면 다음 예제 코드와 같이 처리할 수 있습니다.

var 키워드를 사용하여 변수를 선언 후 괄호에 콤마를 구분하여 숫자 데이터를 넣으면 자동으로 t.Item1, t.Item2 형태로 값이 저장되고 그 값을 사용할 수 있습니다.

> var t = (100, 200);
> Console.WriteLine(t.Item1);
100
> Console.WriteLine(t.Item2);
200

만약, Item1, Item2와 같이 자동 생성되는 형태를 사용하지 않을 때에는 다음과 같이 변수 여러 개를 괄호안에 선언하면 x에는 300이 y에는 400이 저장됩니다.

> var (x, y) = (300, 400);
> Console.WriteLine($"{x}, {y}");
300, 400

장 요약

Console.ReadLine() 메서드로 사용자로부터 데이터를 입력받는 내용과 Convert 클래스로 형식을 변환하는 방법을 알아보았습니다. 추가적으로, var 키워드로 입력되는 형식을 자동으로 유추하여 데이터 형식을 결정시켜주는 방법도 살펴보았습니다. 여러 가지 방법으로 만들어진 변수들을 가지고 연산을 수행하는 연산자에 대해서 다음 장에서 알아보도록 하겠습니다.

연습문제: 원의 넓이 구하기

연습문제: 원의 넓이 구하기

화면으로 원의 반지름을 정수로 입력 받아 원의 넓이를 정수 타입으로 출력하는 프로그램을 작성하세요.

처리 조건

원의 넓이 구하는 공식: 3.14 * 반지름 * 반지름

입력

반지름 입력: 10

출력

원의 넓이:  314

코드: circle_area.*

C# 코드

using System;

class Program
{
    static void Main(string[] args)
    {
        Console.Write("반지름 입력: ");
        int radius = Convert.ToInt32(Console.ReadLine());
        double area = 3.14 * radius * radius;
        Console.WriteLine($"원의 넓이: {(int)area}");
    }
}

이 C# 코드는 사용자로부터 반지름을 입력받아 Convert.ToInt32를 사용하여 문자열을 정수로 변환합니다. 그런 다음 원의 넓이를 계산하고, 결과를 정수로 캐스팅하여 출력합니다.

C 언어 코드

#include <stdio.h>

int main()
{
    int radius;
    double area;

    printf("반지름 입력: ");
    scanf("%d", &radius);

    area = 3.14 * radius * radius;
    printf("원의 넓이: %d\n", (int)area);

    return 0;
}

이 C 코드는 사용자로부터 반지름을 입력받아 scanf를 사용하여 문자열을 정수로 변환합니다. 그런 다음 원의 넓이를 계산하고, 결과를 정수로 캐스팅하여 출력합니다.

연습문제: 원의 넓이 구하기

원의 넓이와 둘레를 구하기

원의 넓이와 둘레를 구하는 예제 코드에 대해 간단히 설명해보겠습니다.

예제 코드

using System;

namespace CalculateAreaAndCircumferenceOfCircleExample
{
    class Program
    {
        static void Main(string[] args)
        {
            // 상수 선언: PI = 3.141592654...
            const float PI = 3.141592654f;

            // 변수 선언
            float r;

            // 사용자로부터 반지름 입력
            Console.Write("반지름: ");
            r = float.Parse(Console.ReadLine());

            // 처리 및 출력
            Console.WriteLine("원의 넓이: {0}", (r * r * PI));
            Console.WriteLine("원의 둘레 길이: {0}", (2 * r * PI));
        }
    }
}

위 코드에서는 먼저, 상수 PI를 3.141592654...로 정의하고, 사용자로부터 반지름을 입력받습니다. 그리고 원의 넓이와 둘레 길이를 계산하여 출력합니다.

원의 넓이는 반지름의 제곱에 상수 PI를 곱한 값입니다. 원의 둘레 길이는 반지름에 2를 곱한 후 상수 PI를 곱한 값입니다.

위 코드를 실행하면, 다음과 같은 결과가 출력됩니다.

반지름: 5
원의 넓이: 78.53982
원의 둘레 길이: 31.41593

위 결과에서는 반지름이 5인 원의 넓이가 약 78.54이고, 둘레 길이가 약 31.42임을 확인할 수 있습니다.

C#은 C언어에 개체 지향 기능을 추가한 언어이므로, 클래스와 메서드, 속성 등의 개념이 등장합니다. 하지만 이 예제에서는 기초적인 입출력과 연산자 활용을 예제로 보여주는 것이므로, 개체 지향적인 개념은 다루지 않았습니다.

C#은 다양한 기능을 제공하는 개체 지향 프로그래밍 언어입니다. 이러한 기능들을 이용하여 더 복잡한 프로그램을 만들어 낼 수 있습니다. 관련된 강좌들을 학습하여 더욱 효과적인 C# 개발을 할 수 있도록 노력해보세요.

퀴즈

1. Console.ReadLine()은 무엇을 반환합니까?
   a. 문자열
   b. 정수
   c. 실수
   d. 불리언
   e. 문자
   정답: a. 문자열
   해설: Console.ReadLine()은 콘솔에서 입력된 문자열을 반환합니다. 반환된 문자열은 프로그램에서 문자열 변수에 할당될 수 있습니다.

2. Console.Read()는 무엇을 반환합니까?
   a. 문자열
   b. 정수
   c. 실수
   d. 불리언
   e. 문자
   정답: e. 문자
   해설: Console.Read()는 콘솔에서 입력된 다음 문자를 반환합니다. 반환된 값은 문자(char) 형식으로 변수에 할당됩니다.

3. Console.ReadLine()은 입력된 값을 어떻게 나타냅니까?
   a. 공백으로 구분된 값들
   b. 쉼표로 구분된 값들
   c. 줄 바꿈으로 구분된 값들
   d. 탭으로 구분된 값들
   e. 모든 입력된 값들이 하나의 문자열로 표시됩니다.
   정답: e. 모든 입력된 값들이 하나의 문자열로 표시됩니다.
   해설: Console.ReadLine()은 콘솔에서 입력된 모든 값을 문자열로 가져옵니다. 따라서 입력된 값들은 구분자 없이 하나의 문자열로 표시됩니다.

4. Console.ReadLine()과 Console.ReadKey() 메서드의 차이점은 무엇인가요?
   a. Console.ReadLine()은 엔터키가 입력될 때까지 사용자의 입력을 기다리지만, Console.ReadKey()는 키 입력을 즉시 읽습니다.
   b. Console.ReadLine()은 숫자와 문자 모두를 읽을 수 있지만, Console.ReadKey()는 문자만 읽을 수 있습니다.
   c. Console.ReadLine()은 콘솔에서 문자열을 입력받습니다. Console.ReadKey()는 콘솔에서 단일 키를 읽습니다.
   d. Console.ReadLine()은 콘솔에서 단일 키를 읽습니다. Console.ReadKey()는 콘솔에서 문자열을 입력받습니다.
   e. Console.ReadLine()은 엔터키를 누르기 전까지 기다립니다. Console.ReadKey()는 엔터키를 기다리지 않고 바로 실행됩니다.
   정답: a. Console.ReadLine()은 엔터키가 입력될 때까지 사용자의 입력을 기다리지만, Console.ReadKey()는 키 입력을 즉시 읽습니다.
   해설: Console.ReadLine()은 사용자가 엔터키를 누르기 전까지 입력을 받지 않습니다. 반면에 Console.ReadKey()는 키 입력을 즉시 읽습니다.

5. Console.ReadLine() 메서드의 반환형은 무엇입니까?
   a. string
   b. int
   c. char
   d. bool
   정답: a. string
   해설: Console.ReadLine()은 사용자로부터 입력받은 값을 string 형태로 반환합니다.

6. 암시적 형식 변환(Implicit Type Conversion)에 대한 설명으로 옳은 것은?
   a. 자동으로 형식을 변환시키는 것이며, 큰 데이터형에서 작은 데이터형으로 변환할 때 발생합니다.
   b. 데이터 손실 없이 작은 데이터형에서 큰 데이터형으로 변환할 때 발생합니다.
   c. 형식 변환을 할 때는 항상 명시적으로 변환해야 합니다.
   d. 암시적 형식 변환은 C#에서 지원하지 않습니다.
   e. 모든 형식은 암시적 형식 변환을 지원합니다.
   정답: b. 데이터 손실 없이 작은 데이터형에서 큰 데이터형으로 변환할 때 발생합니다.
   해설: 암시적 형식 변환은 데이터 손실 없이 작은 데이터형에서 큰 데이터형으로 변환할 때 자동으로 발생합니다.

7. 명시적 형식 변환(Explicit Type Conversion)에 대한 설명으로 옳은 것은?
   a. 자동으로 형식을 변환시키는 것이며, 큰 데이터형에서 작은 데이터형으로 변환할 때 발생합니다.
   b. 데이터 손실 없이 작은 데이터형에서 큰 데이터형으로 변환할 때 발생합니다.
   c. 형식 변환을 할 때는 항상 명시적으로 변환해야 합니다.
   d. 명시적 형식 변환은 C#에서 지원하지 않습니다.
   e. 모든 형식은 명시적 형식 변환을 지원합니다.
   정답: c. 형식 변환을 할 때는 항상 명시적으로 변환해야 합니다.
   해설: 명시적 형식 변환은 암시적 변환이 불가능한 경우에 사용되며, 반드시 코드에 변환을 명시해야 합니다.

1.1 퀴즈

(1) Console.ReadLine()으로 입력받은 문자열을 정수로 변환해 출력하는 올바른 방법을 고르세요.

a.

int input = Console.ReadLine();

b.

string input = Console.ReadLine();
int number = Convert.ToInt32(input);

c.

string input = Console.ReadLine();
int number = Convert.ToString(input);

d.

string input = Console.ReadLine();
int number = Convert.ToDouble(input);

정답: b

Console.ReadLine() 메서드는 입력값을 문자열(string) 로 받습니다.
정수로 변환하려면 Convert.ToInt32() 메서드를 사용해야 합니다.

(2) 다음 중 실수형 데이터로 변환하는 메서드가 아닌 것을 고르세요.

a. Convert.ToFloat()
b. Convert.ToDouble()
c. Convert.ToDecimal()
d. Convert.ToSingle()

정답: a

• Convert.ToFloat() 메서드는 존재하지 않습니다.
• Convert.ToSingle() → float 형식으로 변환
• Convert.ToDouble() → double 형식으로 변환
• Convert.ToDecimal() → decimal 형식으로 변환

1.2 연습문제: 콘솔 입력값을 정수로 변환하여 출력하기

다음 소스 코드를 완성하여 콘솔로부터 정수를 입력받고 출력하는 프로그램을 만드세요.

코드

// 콘솔로부터 정수 입력받기
using System;

class ReadLineIntegerPractice
{
    static void Main()
    {
        Console.WriteLine("정수를 입력하세요: ");
        int number = Convert.ToInt32(Console.ReadLine());
        Console.WriteLine(number);
    }
}

실행 결과 예시

정수를 입력하세요:
1234
1234

정답

Convert.ToInt32(Console.ReadLine())

해설

• Console.ReadLine()은 문자열(string) 값을 반환합니다.
• 입력받은 문자열을 정수로 변환하려면 Convert.ToInt32()를 사용해야 합니다.
• 예를 들어, "1234"(문자열)를 1234(정수)로 변환하려면 Convert.ToInt32("1234")를 사용합니다.