김민찬 2주차 수업 후 과제

카테고리 없음

김민찬 2주차 수업 후 과제

content9349 2025. 9. 10. 14:17

식별자 (Identifier)

식별자는 C프로그램을 구성하는 기본 단위인 토큰(token)의 일종으로, 변수, 함수, 배열 등에 붙이는 이름이야. 프로그래머가 직접 정의하는 이름으로, 몇 가지 규칙을 따라야 해:

영문자, 숫자, 언더스코어(_)만 사용 가능
첫 글자는 반드시 영문자나 언더스코어로 시작
대소문자를 구분함
C언어의 예약어(키워드)는 사용할 수 없음

리터럴 (Literal)

리터럴은 프로그램에서 직접 표현되는 값 자체를 의미해. 변수에 대입되거나 연산에 사용되는 고정된 값이지:

정수 리터럴: 123, -10
실수 리터럴: 3.14, 2.0e-3
문자 리터럴: 'A', '1'
문자열 리터럴: "Hello, World!"

자료형 (Data Type)

자료형은 처리하고 저장하고자 하는 데이터의 형태를 나타내. C언어의 기본 자료형은:

정수형: int, short, long, char
실수형: float, double
문자형: char
불린형: C99부터 _Bool 지원
void: 값이 없음을 나타냄

변수 (Variable)

변수는 데이터를 저장하기 위해 프로그램에서 사용하는 이름이 붙은 메모리 공간이야:

선언 방법: 자료형 변수명;
초기화 방법: 자료형 변수명 = 초기값;
변수는 사용하기 전에 반드시 선언해야 함
변수의 이름은 식별자 규칙을 따라야 함

전처리기 (Preprocessor)

전처리기는 컴파일 과정의 첫 단계에서 실행되는 프로그램으로, 소스 코드를 컴파일하기 전에 가공하는 역할을 해:

항상 '#'으로 시작하는 지시문을 사용
주요 전처리기 지시문:
- #include: 헤더 파일을 현재 파일에 포함시킴
- #define: 매크로를 정의함
- #ifdef, #ifndef, #endif: 조건부 컴파일에 사용

예를 들어, #include <stdio.h>는 표준 입출력 라이브러리 헤더 파일을 포함시켜 printf 같은 함수를 사용할 수 있게 해줘

연산자 (Operator)

연산자는 특정 연산을 수행하는 기호야:

산술 연산자: +, -, *, /, %
대입 연산자: =, +=, -=, *=, /=, %=
비교 연산자: ==, !=, >, <, >=, <=
논리 연산자: &&(AND), ||(OR), !(NOT)
비트 연산자: &, |, ^, ~, <<, >>
기타 연산자: sizeof(), 조건 연산자(?:), 콤마 연산자(,)

============================================================================================

#include <iostream> 이 줄은 C++에서 입력을 받거나 화면에 출력할 때 사용하는 iostream이라는 표준 라이브러리를 가져오는 코드야. std::cout 같은 걸 쓰려면 이게 꼭 필요해.

#include <stdio.h> 이건 C언어에서 입출력을 담당하는 stdio.h라는 표준 라이브러리를 가져오는 코드야. printf 같은 C스타일의 출력 함수를 쓰려면 이걸 포함시켜야 해.

int main() 모든 C++ 프로그램은 main이라는 함수에서 시작해. int는 이 함수가 실행된 후에 정수 값을 돌려준다는 의미이고, 이 함수가 바로 우리 프로그램의 첫걸음이지.

{ 이 중괄호는 main 함수가 어디서부터 시작하는지 알려주는 기호야. 함수의 내용이 이제부터 시작된다는 뜻이야.

std::cout << "Hello World!\n"; 이 코드는 화면에 "Hello World!"라는 메시지를 출력하는 부분이야. std::cout은 표준 출력 장치(보통 모니터)를 의미하고, <<는 "이 내용을 std::cout으로 보내라!"는 의미야. 그리고 "Hello World!\n"에서 \n은 '새로운 줄로 바꿔라'라는 뜻이라서, 메시지를 출력하고 나서 다음 줄로 커서를 옮겨줘.

printf("Hello World"); 이것도 화면에 "Hello World"를 출력하는 코드인데, 위에서 본 C++ 스타일이 아니라 C언어 스타일이야. printf는 stdio.h에 있는 함수인데, 괄호 안의 문자열을 그대로 출력해줘. 여기서는 \n이 없어서 이 메시지를 출력한 다음에는 커서가 같은 줄에 그대로 남게 돼.

} 마지막 중괄호는 main 함수가 여기서 끝난다는 걸 알려줘

============================================================================================

두 개의 코드가 있어. 둘 다 "Hello World!"라는 문구를 화면에 출력하는 역할을 해. 하지만 그 방식에서 작은 차이들이 있단다.

첫 번째 코드를 설명해줄게.

먼저, include <iostream>이라는 구문으로 시작해. 이건 우리가 키보드에서 입력받거나 화면에 뭔가를 보여줄 때 쓰는 기능들을 담고 있는 'iostream'이라는 상자, 그러니까 라이브러리를 사용하겠다는 뜻이야.

그다음에는 int main() 이라는 부분이 나와. 이건 '여기부터가 프로그램이 시작되는 곳이다!'라고 컴퓨터에게 알려주는 약속된 부분이야. 우리 프로그램은 이 'main'이라는 함수 안에서 실행되지.

그리고 가장 중요한 출력 부분인 std::cout << "Hello World!\n";이 있어. 여기서 핵심은 std:: 이라는 부분이야. C++에서는 다양한 기능들을 각각의 'std'라는 큰 이름표 아래에 모아두었거든. 그래서 우리가 cout이라는 출력 기능을 쓰고 싶으면, 이 cout이 std 이름표 아래에 있다는 걸 std::cout 이렇게 꼭 명시해줘야 해. 이건 마치 "서울의 강남구"라고 정확히 이야기하는 것과 비슷하다고 볼 수 있지. 뒤에 \n은 "Hello World!"를 화면에 보여주고 나서, 다음 줄로 커서를 옮겨달라는 신호야.

이제 두 번째 코드를 설명해줄까?

이 코드도 마찬가지로 include <iostream>으로 'iostream' 라이브러리를 사용하겠다고 알리는 것으로 시작해.

그런데 여기에는 using namespace std; 이라는 새로운 줄이 추가되어 있어. 이건 "야, 이제부터 'std'라는 이름표 안에 있는 기능들을 내가 계속 쓸 건데, 그때마다 앞에 std::라고 붙이는 거 번거로우니까, 그냥 앞으로 std 안에 있는 거라고 알아서 생각하고 처리해 줘!" 라고 컴파일러에게 미리 선언해 주는 문장이야. 그래서 이 선언 덕분에 그 다음부터는 std::cout이 아니라 그냥 cout이라고만 써도 되는 거야.

그다음에는 똑같이 int main()으로 프로그램의 시작을 알리지.

그리고 출력을 하는 cout << "Hello World!"; 부분이 나와. 위에서 using namespace std;를 해두었기 때문에, 여기서는 std::를 붙이지 않고 그냥 cout만 써도 화면에 "Hello World!"를 잘 출력할 수 있어. 참고로 이 코드에는 아까 봤던 \n이 없어서, 메시지를 출력한 뒤에 다음 줄로 커서가 옮겨지지 않고 같은 줄에 남아있게 될 거야.

마지막으로 return 0;이라는 부분이 있어. main 함수는 실행이 끝나면 어떤 값을 돌려주게 되어 있는데, 0을 돌려주는 건 "나는 아무 문제 없이 잘 끝났어!" 하고 운영체제에게 알려주는 약속 같은 거란다. 첫 번째 코드에는 이 줄이 없지만, C++에서는 main 함수의 경우 이 return 0;이 없으면 컴파일러가 자동으로 추가해 주는 경우가 대부분이야.

정리해보면, 가장 큰 차이는 cout을 사용할 때 std::를 매번 붙여주느냐 (std::cout), 아니면 using namespace std;로 미리 선언해두고 std:: 없이 편하게 사용하느냐 (cout) 의 차이야. 그리고 줄바꿈 문자(\n) 사용 여부나 return 0;을 명시했는지 안 했는지 정도의 차이가 있단다!

============================================================================================

============================================================================================

지금 네가 보여준 코드는 C 언어에서 사용하는 scanf라는 함수 때문에 오류가 날 가능성이 높아. 특히 마이크로소프트 비주얼 스튜디오 같은 개발 환경에서 많이 겪는 문제인데, 왜냐하면 scanf 함수가 예전에 해킹 같은 보안 문제에 취약한 부분이 있었거든.

그래서 비주얼 스튜디오 같은 곳에서는 scanf 대신 좀 더 안전한 scanf_s라는 함수를 사용하라고 권장하고 있어. 만약 네가 scanf를 사용하면, 컴퓨터가 "어! 이 함수는 보안에 문제가 있을 수 있어요!" 하면서 경고나 오류를 띄우는 거지.

그럼 이걸 어떻게 해결할까?

두 가지 방법이 있어.

첫 번째 방법은 경고를 잠깐 무시하게 하는 거야. 이 방법은 코드 맨 위에 pragma warning(disable:4996) 이라는 특별한 명령 한 줄을 추가하는 거야. 이걸 써주면 컴파일러가 "아, 그래? 이 부분은 경고 뜨더라도 그냥 넘어갈게" 하고 알려주는 거지. 말 그대로 '이 경고는 잠깐 무시해줘'라고 선언하는 셈이야.

코드를 기준으로 말하면, 프로그램을 시작하는 가장 첫 줄에 이 문장을 넣어주면 돼. 그러면 원래 네가 썼던 scanf 코드가 오류 없이 잘 실행될 거야.

두 번째 방법은 아예 안전한 함수로 바꿔서 쓰는 거야. 이게 더 권장되는 방법인데, scanf라고 쓴 부분을 그냥 scanf_s로만 바꿔주면 돼. 다른 건 아무것도 고칠 필요 없고, 딱 그 이름만 바꿔주면 돼. scanf_s는 보안에 신경 써서 만들어진 scanf의 개선된 버전이라서, 이걸 쓰면 비주얼 스튜디오 같은 곳에서도 아무런 경고 없이 코드가 잘 돌아갈 거야.

그리고 한 가지 더, 코드에 보면 &num 이라고 쓰여있잖아? 여기서 & 기호는 정말 중요해. 우리가 숫자를 입력받을 때, 그 숫자를 num이라는 변수에 저장해야 하는데, &는 그 num 변수가 메모리에서 어디에 위치하는지 컴퓨터에게 알려주는 역할을 해줘. 그래야 입력받은 값이 정확히 num이라는 공간에 들어가서 저장될 수 있거든. 그래서 이 & 기호는 절대 빼먹으면 안 되는 부분이야!

#include <iostream> // C++의 표준 입출력 라이브러리

int main()
{
    int num;
    std::cout << "숫자 하나를 입력하세요="; // printf 대신 cout 사용
    std::cin >> num; // scanf 대신 cin 사용
    std::cout << "입력받은 수는 " << num << "입니다." << std::endl; // 줄바꿈을 위해 endl 사용
    return 0;
}

C 스타일과 C++ 스타일의 주요 차이점을 설명해줄게:

헤더 파일: C에서는 <stdio.h>를 사용했지만, C++에서는 <iostream>을 사용해. 이 라이브러리는 C++의 입출력 객체들을 제공해.
출력 방식: C에서는 printf() 함수를 사용했는데, C++에서는 std::cout과 << 연산자를 사용해. 이게 C++의 스트림 방식이야. 포맷 지정자(%d)가 필요 없이 자동으로 데이터 타입을 인식해서 출력해줘서 더 편리해!
입력 방식: C에서는 scanf("%d", &num)처럼 포맷 지정자와 변수의 주소(&)를 명시해야 했지만, C++에서는 std::cin >> num처럼 더 간단하게 쓸 수 있어. 변수의 주소를 직접 넘겨줄 필요가 없어졌어.
줄바꿈: C에서는 \n 문자를 사용했지만, C++에서는 std::endl을 사용할 수 있어. endl은 줄바꿈과 함께 출력 버퍼를 비워주는 역할도 해.
네임스페이스: std::는 C++ 표준 라이브러리의 네임스페이스야. 이렇게 명시해주면 다른 라이브러리와 이름이 충돌하는 걸 방지할 수 있어.

============================================================================================

#include <iostream> // 입출력 스트림 라이브러리, C++의 표준 입출력을 위한 헤더

int main() // C++에서는 void를 생략해도 됨
{ // main() 함수의 시작
    int num1, num2; // 변수 선언문, 실행문보다 먼저 씀
    /* 변수명: 영문자(A-Z, a-z), 숫자(0-9), 밑줄(_)로 구성
    변수(variable): 프로그램이 실행되는 동안 자료를
    기억시키기 위한 기억장소의 이름 */
    
    num1 = 100; // 대문자와 소문자는 다른 변수로 인식
    num2 = -300; // 변수에 상수 대입
    
    std::cout << "두 수의 합은 " << (num1 + num2) << "입니다." << std::endl;
    // C++의 표준 출력 객체와 스트림 연산자를 사용
    // endl은 줄바꿈과 함께 출력 버퍼를 비워줌
    
    return 0;
} // main() 함수의 끝

C++로 바꾸면서 달라진 주요 부분은:

stdio.h 대신 iostream 헤더 사용
printf() 대신 std::cout과 << 연산자 사용
포맷 지정자(%d) 대신 직접 변수를 스트림에 삽입
\n 대신 std::endl로 줄바꿈 처리
main(void) 대신 간단히 main()으로 표현 가능

============================================================================================

리터럴은 쉽게 말해, 프로그램 코드 안에서 그 값 자체가 되는 것들을 의미해. 변수처럼 값을 담는 공간이 아니라, 그냥 그 값 그 자체인 거지!

주요 종류는 이렇게 있어:

정수 리터럴 (Integer Literals)
- 예시: 123, -5, 0xFF (16진수)
- 숫자! 우리가 아는 정수 값을 코드에 직접 쓰는 거야.
부동 소수점 리터럴 (Floating-Point Literals)
- 예시: 3.14, -0.5, 1.23e-4
- 소수점이 있는 숫자! 실수 값을 코드에 직접 쓰는 거지.
문자 리터럴 (Character Literals)
- 예시: 'A', 'z', '\n' (줄바꿈)
- 단 하나의 문자를 작은따옴표('') 안에 넣는 거야.
문자열 리터럴 (String Literals)
- 예시: "Hello World!", "안녕하세요"
- 여러 문자를 이어 붙인 텍스트를 큰따옴표("") 안에 넣는 거지.
불리언 리터럴 (Boolean Literals)
- 예시: true, false
- 참과 거짓, 딱 두 가지 상태를 나타낼 때 써.
포인터 리터럴 (Pointer Literals)
- 예시: nullptr
- 아무것도 가리키지 않는 텅 빈 포인터 값을 의미해.

요약하자면, 코드에 숫자를 쓰든, 글자를 쓰든, 문장을 쓰든, 참/거짓을 쓰든... "그 값 그대로" 코드에 표현하는 것이 바로 리터럴이라고 보면 돼!

============================================================================================

이스케이프 시퀀스란?

이스케이프 시퀀스(escape sequence)는 프로그래밍 언어에서 특수한 기능을 수행하거나 일반적으로 표현하기 어려운 문자들을 표현하기 위해 사용하는 특별한 문자 조합이야. 주로 백슬래시(\)와 다른 문자를 조합해서 만들어져.

쉽게 말하면, 프로그래밍할 때 화면에 그대로 표시할 수 없는 특수한 문자나 동작(줄바꿈, 탭 등)을 표현하기 위한 코드라고 생각하면 돼!

자주 사용되는 이스케이프 시퀀스 예시

가장 흔히 사용되는 이스케이프 시퀀스들은:

\n: 줄바꿈 (new line)
\t: 탭 (tab)
\\: 백슬래시 문자 자체를 표현
\": 큰따옴표 문자
\': 작은따옴표 문자
\0: 널 문자 (문자열의 끝을 나타냄)

이스케이프 시퀀스를 사용하는 프로그래밍 언어들

이스케이프 시퀀스는 정말 많은 프로그래밍 언어에서 사용돼. 주요 언어들을 살펴보면:

C/C++ - 가장 기본적인 이스케이프 시퀀스를 제공하는 언어들이야
Java - C와 비슷한 이스케이프 시퀀스 체계를 사용해
Python - 문자열 내에서 다양한 이스케이프 시퀀스를 지원해
JavaScript - 웹 개발에서 자주 사용되는 언어로, 문자열 내 이스케이프 시퀀스 지원
C# - .NET 환경에서 사용되는 언어로 다양한 이스케이프 시퀀스 제공
PHP - 웹 서버 스크립트 언어로 이스케이프 시퀀스 지원
Ruby - 다양한 문자열 처리를 위한 이스케이프 시퀀스 제공
Go - 현대적인 시스템 프로그래밍 언어로 이스케이프 시퀀스 지원
Swift - iOS/macOS 개발 언어로 이스케이프 시퀀스 사용
Rust - 시스템 프로그래밍 언어로 안전한 메모리 관리와 함께 이스케이프 시퀀스 지원

사실 거의 모든 현대 프로그래밍 언어들은 어떤 형태로든 이스케이프 시퀀스를 지원한다고 보면 돼! 이건 문자열을 다루는 데 정말 기본적인 기능이거든.

============================================================================================

구분작은따옴표 ('A')큰따옴표 ("A")

의미	문자 (Character)	문자열 (String)
저장하는 값	하나의 문자 자체를 ASCII 또는 유니코드 값으로 저장	여러 문자들의 나열 + 문자열의 끝을 나타내는 널 문자(\0)
메모리 크기	보통 1바이트 (char 타입)	문자의 개수 + 1바이트 (널 문자) 만큼의 크기
자료형	char 타입 (정수형으로 취급)	char 배열 또는 const char* (포인터) 타입으로 취급
예시	char ch = 'A';	char str[] = "A"; 또는 const char* s = "A";
활용	- 단일 문자 비교 (e.g., if (ch == 'a'))	- 단어, 문장 등 텍스트 표현
	- 특정 문자의 ASCII 값 이용	- 화면에 메시지 출력 (e.g., cout << "Hello";)
중요 특징	하나의 값 (A는 정수 65)	\0 (널 문자)로 문자열의 끝을 표시함

좀 더 자세히 설명하자면...

작은따옴표는 '글자 하나': 예를 들어 'A'는 컴퓨터 내부적으로는 'A'에 해당하는 숫자 값 (아스키 코드 65)으로 저장돼. 그래서 'A' + 1 이런 연산을 하면 'B'(아스키 코드 66)가 나올 수도 있어.
큰따옴표는 '글자들의 나열': "A"는 그냥 'A'라는 글자 하나가 아니라, 'A'라는 글자 뒤에 **널 문자(\0)**라는 숨겨진 문자가 하나 더 붙어있어. 널 문자는 '아, 여기서 문자열이 끝났구나!' 하고 컴퓨터에게 알려주는 표식이야. 그래서 "A"는 실제로는 'A'와 \0 두 개의 문자로 이루어진 문자열인 셈이지.

예를 들어,

char ch = 'H'; ➡️ ch에는 'H'의 아스키 코드 값인 72가 저장돼.
char str[] = "Hi"; ➡️ str 배열에는 'H', 'i', 그리고 숨겨진 \0 (널 문자)가 순서대로 저장돼.

이 차이점 때문에 C++에서 std::cout << 'A';와 std::cout << "A";는 동작 방식이 달라지는 거야. 하나는 단일 문자, 다른 하나는 문자열로 인식되거든.

============================================================================================

쉽게 말해, 변수를 사용하기 전에 "이 변수는 이런 종류의 데이터를 담을 거야!" 하고 미리 신고해야 하는 언어들이 있고, "일단 써! 어떤 데이터를 담는지 보고 컴퓨터가 알아서 판단해 줄게!" 하는 언어들이 있어.

1. 변수를 사용하기 전에 반드시 선언해야 하는 언어 (정적 타입 언어)

이런 언어들은 변수를 만들 때 **'자료형(Data Type)'**을 명시해줘야 해. 예를 들어 "이 변수에는 정수만 담을 거야" 또는 "이 변수에는 글자만 담을 거야" 하고 미리 약속하는 거지. 이렇게 자료형을 미리 정해두는 걸 **'정적 타입(Static Type)'**이라고도 부른단다.

✅ 왜 선언해야 할까?

컴파일 단계에서 오류 검출: 미리 자료형을 정해두니까, 혹시 잘못된 타입의 데이터를 넣으려 하면 프로그램이 실행되기 전에 오류를 잡아낼 수 있어. 덕분에 좀 더 안정적인 프로그램을 만들 수 있지.
성능 효율: 컴퓨터가 변수에 어떤 종류의 데이터가 들어올지 미리 아니까, 메모리를 효율적으로 관리하고 더 빠르게 코드를 실행할 수 있어.
코드 가독성: 코드를 읽는 사람이 변수에 어떤 종류의 데이터가 들어갈지 바로 알 수 있어서 이해하기 편해.

✅ 이런 언어들이 있어:

C / C++: 대표적인 언어들이지! int num = 10; (정수), char name = 'A'; (문자) 처럼 반드시 앞에 자료형을 써줘야 해.
Java: C++과 비슷하게 엄격하게 자료형을 선언해야 해.
C#: 자바와 마찬가지로 정적 타입 언어야.
Go, Swift, Kotlin: 이 언어들은 최신 언어인데, 기본적으로는 정적 타입 언어야. 하지만 똑똑하게도 **'타입 추론(Type Inference)'**이라는 기능이 있어서, 어떤 값을 처음 할당해 줄 때 자료형을 명시하지 않아도 컴퓨터가 알아서 추론해 주기도 해. 그래도 기본적으로는 선언 개념이 들어가 있어. (예: Go에서 var num = 10 또는 num := 10이라고 쓰면 int 타입으로 알아서 인식)

2. 변수를 사용하기 전에 선언하지 않아도 되는 언어 (동적 타입 언어)

이런 언어들은 변수를 선언할 때 자료형을 명시할 필요가 없어. 그냥 변수명 = 값처럼 바로 사용하면 돼! 컴퓨터가 프로그램이 실행되는 동안(런타임) 변수에 어떤 값이 들어가는지 보고 그때그때 자료형을 결정하지. 이걸 '동적 타입(Dynamic Type)' 언어라고 불러.

✅ 왜 선언하지 않아도 될까?

개발 속도 향상: 복잡한 자료형을 미리 생각하고 선언할 필요가 없어서, 코드를 더 빠르게 작성할 수 있어. 프로토타입 만들 때나 간단한 스크립트 짤 때 유용해.
유연성: 한 변수에 처음에는 숫자를 넣었다가 나중에는 문자열을 넣는 식으로, 필요에 따라 변수의 자료형을 바꿀 수 있는 유연성이 있어.

✅ 이런 언어들이 있어:

Python (파이썬): 정말 대표적인 동적 타입 언어! num = 10, name = "벨라시엘" 처럼 자료형 없이 바로 변수를 만들어 쓸 수 있어 .
JavaScript (자바스크립트): 웹 브라우저에서 많이 쓰이는 언어지! var, let, const 같은 키워드는 쓰지만, 자료형은 명시하지 않아도 돼.
Ruby (루비): 파이썬처럼 간결하고 유연한 문법을 가진 동적 타입 언어야.
PHP: 웹 개발에 많이 쓰이는 언어로, 변수 선언 시 자료형을 명시하지 않아.
Perl (펄): 아주 오래된 언어인데, 동적 타입의 특징을 가지고 있어.

C/C++ 연산자 우선순위 (높은 순)

괄호 연산자: (), [], ->, .
- 함수 호출, 배열 접근, 구조체/클래스 멤버 접근 등 가장 높은 우선순위
단항 연산자: !, ~, ++, --, +, -, *, &, sizeof
- 부정, 증감, 주소 참조, 역참조 등의 연산자들
산술 연산자:
- 곱셈/나눗셈/나머지: *, /, %
- 덧셈/뺄셈: +, -
비트 시프트 연산자: <<, >>
- 비트를 왼쪽이나 오른쪽으로 이동
관계 연산자: <, <=, >, >=
- 크기 비교
등가 연산자: ==, !=
- 같음/다름 비교
비트 AND: &
비트 XOR: ^
비트 OR: |
논리 AND: &&
논리 OR: ||
조건(삼항) 연산자: ? :
대입 연산자: =, +=, -=, *=, /=, %=, <<=, >>=, &=, ^=, |=
- 모든 대입 연산자는 우선순위가 가장 낮아

연산자 우선순위가 같을 때는 결합 방향(associativity)에 따라 연산 순서가 결정돼. 대부분의 연산자는 왼쪽에서 오른쪽으로 결합하지만, 단항 연산자와 대입 연산자는 오른쪽에서 왼쪽으로 결합해!

============================================================================================

산술

덧셈

숫자 더하기

뺄셈

숫자 빼기

곱셈

숫자 곱하기

나눗셈

숫자 나누기

나머지

나눗셈 후 나머지 값

대입

기본 대입

변수에 값 할당

복합 대입

+= -= *= /= %=

산술 연산 후 대입

비교

같음

두 값이 같은지 비교

같지 않음

두 값이 다른지 비교

크다

왼쪽이 큰지 비교

작다

왼쪽이 작은지 비교

크거나 같다

왼쪽이 크거나 같은지 비교

작거나 같다

왼쪽이 작거나 같은지 비교

논리

AND (그리고)

양쪽 조건 모두 참일 때 참

OR (또는)

둘 중 하나라도 참일 때 참

NOT (아님)

조건을 반대로 바꿈

증감

증가 (1 더하기)

변수 값을 1 증가

감소 (1 빼기)

변수 값을 1 감소

삼항

조건 연산

? :

조건에 따라 두 값 중 하나 선택

JS 특수

엄격히 같음

===

값과 타입 모두 같은지 비교

엄격히 같지 않음

!==

값이나 타입이 다른지 비교

1. 나머지 연산자 활용 문제 (2023년 2회)

#include<stdio.h>
int main() {
    int d = 55;
    int n = 4;
    int r = 0, q = 0;
    r = d;
    while(r >= 4) {
        r = r - n;
        q++;
    }
    printf("%d 그리고 ", q);
    printf("%d", r);
}

답: 13 그리고 3

설명: 이 문제는 나눗셈의 몫과 나머지를 구하는 알고리즘이야. 55를 4로 나누면 몫은 13이고 나머지는 3이 되지. 코드에서는 반복문을 통해 4씩 빼면서 몇 번 뺐는지(q)를 세고, 남은 값(r)이 4보다 작을 때 반복을 멈추는 방식으로 구현했어.

2. 재귀 함수와 연산자 활용 문제 (2023년 1회)

#include<stdio.h>
int SumNTo1(int n) {
    if(n <= 1)
        return 1;
    else
        return n + (가);
}
int main() {
    int result = SumNTo1(100);
    printf("%d", result);
}

답: SumNTo1(n-1)

설명: 이 문제는 재귀 함수를 사용해 1부터 n까지의 합을 구하는 코드야. n이 1보다 작거나 같으면 1을 반환하고, 그렇지 않으면 현재 n 값과 n-1까지의 합을 더해서 반환해. 그래서 (가)에는 SumNTo1(n-1)이 들어가야 해.

============================================================================================

1. 재귀 함수와 곱셈 연산 문제 (2023년 2회)

#include<stdio.h>
int recursive(int n) {
    if(n <= 1) 
        return 1;
    else 
        return n*n+recursive((가));
}
int main() {
    int i;
    scanf("%d", &i);
    printf("%d ", recursive(i));
}

답: n-1

설명: 이 문제는 재귀 함수를 사용해 n^2 + (n-1)^2 + ... + 1^2 값을 계산하는 코드야. 각 단계에서 현재 숫자의 제곱을 더하고, 다음 단계로 넘어갈 때 숫자를 1 감소시켜야 하기 때문에 (가)에는 n-1이 들어가야 해.

2 소수 판별 연산 문제

#include <stdio.h>
int isPrime(int number)
{ 
  int i; 
  for (i=2; i<number; i++) 
  { 
    if (number % i == 0) return 0; 
  } 
  return 1;
}
int main(void)

설명: 이 코드는 소수를 판별하는 함수야. 숫자가 2부터 자기 자신 전까지의 어떤 수로도 나누어 떨어지지 않으면 소수라고 판단해. number % i == 0은 나머지 연산자를 사용해서 나누어 떨어지는지 확인하는 부분이야. 나머지가 0이면 소수가 아니므로 0을 반환하고, 모든 수로 나누어 떨어지지 않으면 1을 반환해서 소수임을 알려줘.

현재글김민찬 2주차 수업 후 과제

content9349 님의 블로그

content9349 님의 블로그 입니다.

Today :
Yesterday :

content9349 님의 블로그