C/C++ 식별자, 상수, 자료형, 변수, 전처리기, 연산자 예제

C/C++ 식별자, 상수, 자료형, 변수, 전처리기, 연산자 예제

아래 예제는 단일 파일(C++) 안에 요청하신 모든 요소를 담았습니다. 모든 줄에 상세 주석을 달아 흐름과 문법 포인트를 하나씩 짚습니다.

// ===================== 전처리기(Preprocessor) 영역 =====================

#include <iostream>              // 표준 입출력을 위한 헤더 포함 (전처리 지시문)
#include <cstdint>               // 고정 폭 정수형 자료형(int32_t 등) 사용을 위한 헤더
#include <cstring>               // C 문자열 함수(strlen 등) 사용을 위한 헤더

#define PI 3.1415926535          // 매크로 상수(리터럴 치환) 정의: 식별자 PI는 소스에서 상수로 확장됨
#define SQR(x) ((x) * (x))       // 매크로 함수: 인자 x를 제곱한 결과로 전개되는 전처리 매크로

// 전처리 조건부 컴파일: DEBUG가 정의되면 디버그 로그를 활성화
#ifdef DEBUG
  #define DBG(msg) std::cout << "[DEBUG] " << msg << "\n"  // 디버그 로깅 매크로
#else
  #define DBG(msg)                   // 아무것도 하지 않음
#endif

// ===================== 식별자(Identifiers)와 자료형(Data types) =====================

// 사용자 정의 자료형: 구조체(클래스) 정의 — 식별자: Vec2
struct Vec2 {                      // 식별자 Vec2는 사용자 정의 자료형 이름
    double x;                      // 멤버 변수 x: 자료형 double, 식별자 x
    double y;                      // 멤버 변수 y: 자료형 double, 식별자 y
    double len2() const {          // 멤버 함수 len2: 길이 제곱 반환, const 함수
        return x * x + y * y;      // 산술 연산자 *와 + 사용
    }                              // 멤버 접근 시 점(.) 연산자 사용 예정
};

// 열거형(enum) 상수 — 식별자: Color, RED/GREEN/BLUE는 열거 상수
enum class Color { RED = 1, GREEN = 2, BLUE = 4 };  // 열거 상수: 정수형 상수 집합(비트 플래그처럼 사용 가능)

// 별칭 자료형(using/typedef) — 식별자: i32
using i32 = int32_t;               // i32는 int32_t의 타입 별칭(식별자)

// 함수 원형 선언(프로토타입) — 식별자: add
int add(int a, int b);             // 함수 식별자 add, 매개변수 a/b는 식별자, 자료형 int

// ===================== 전역 상수와 변수 =====================

const double E = 2.718281828;      // const 상수(변경 불가) — 상수 식별자 E, 자료형 double, 실수 리터럴
constexpr int MAX_N = 8;           // 컴파일 시간 상수 constexpr — 정수 리터럴 8

// 전역 변수(예시) — 가능하면 지역으로 제한하는 것이 일반적
int global_counter = 0;            // 전역 변수 식별자, 대입 연산자 =, 정수 리터럴 0

// ===================== 메인 함수 시작 =====================

int main() {                                            // 프로그램 진입점: 식별자 main, 반환 자료형 int
    std::cout << "=== C/C++ 문법 종합 예제 ===\n";      // 문자열 리터럴 출력(상수), << 연산자(스트림 삽입)

    // ----- 기본 자료형과 변수(Variables) -----
    int a = 10;                                        // 변수 a: 자료형 int, 식별자 a, 대입(초기화) 연산자 =
    int b = 3;                                         // 변수 b: 자료형 int
    double d = 3.5;                                    // 변수 d: 자료형 double, 실수 리터럴
    char ch = 'A';                                     // 문자 상수 리터럴('A'), 자료형 char
    bool ok = true;                                    // 불리언 상수(true/false), 자료형 bool
    unsigned u = 42u;                                  // 부호 없는 정수형, 접미사 u 사용

    // ----- 연산자: 산술, 대입, 복합대입 -----
    int sum = a + b;                                   // 산술 +, 대입 = 
    int diff = a - b;                                  // 산술 -
    int prod = a * b;                                  // 산술 *
    int quot = a / b;                                  // 산술 / (정수 나눗셈)
    int rem  = a % b;                                  // 산술 % (나머지)
    a += 5;                                            // 복합 대입 +=
    b *= 2;                                            // 복합 대입 *=

    // ----- 비교, 논리 연산자 -----
    bool eq  = (a == b);                               // 비교 == 
    bool ne  = (a != b);                               // 비교 !=
    bool lt  = (a < b);                                // 비교 <
    bool ge  = (a >= b);                               // 비교 >=
    bool both = (lt && ge);                            // 논리 AND &&
    bool either = (lt || ge);                          // 논리 OR ||
    bool neg = !ok;                                    // 논리 부정 !

    // ----- 비트 연산자 -----
    int m = 0b1010;                                    // 이진 리터럴(10 진수로 10)
    int n = 0b0111;                                    // 이진 리터럴(7)
    int band = m & n;                                  // 비트 AND &
    int bor  = m | n;                                  // 비트 OR |
    int bxor = m ^ n;                                  // 비트 XOR ^
    int bnot = ~m;                                     // 비트 NOT ~
    int shl  = m << 2;                                 // 비트 왼쪽 시프트 <<
    int shr  = m >> 1;                                 // 비트 오른쪽 시프트 >>

    // ----- 삼항 조건 연산자 -----
    int bigger = (a > b) ? a : b;                      // 조건 ? 참 : 거짓

    // ----- sizeof와 형변환 -----
    size_t si = sizeof(double);                        // 피연산자 크기(바이트) — sizeof
    double casted = static_cast<double>(sum);          // 명시적 형변환(static_cast)

    // ----- 주소 연산자, 포인터, 역참조 -----
    int *p = &sum;                                     // 주소 연산자 &: sum의 주소를 포인터 p에 저장
    *p = *p + 1;                                       // 역참조 *: 포인터가 가리키는 원소에 접근/수정(산술 +)

    // ----- 배열과 첨자 연산자 -----
    int arr[MAX_N] = {0};                              // 배열 선언, 중괄호 초기화 — 첨자 연산자([]) 사용 예정
    arr[0] = 7;                                        // 첨자([])로 원소 접근 및 대입
    arr[1] = arr[0] + 3;                               // 배열 원소 간 산술 및 대입

    // ----- 구조체(클래스)와 멤버 접근 연산자 -----
    Vec2 v{3.0, 4.0};                                  // 중괄호 초기화(자료형 double 멤버 x, y)
    double l2 = v.len2();                              // 멤버 함수 호출, 점(.) 연산자
    v.x = v.x + 1.0;                                   // 멤버 접근 후 산술/대입

    // ----- 포인터로 구조체 접근(-> 연산자) -----
    Vec2 *vp = &v;                                     // v의 주소를 구조체 포인터 vp에 저장
    double l2_again = vp->len2();                      // 화살표(->)로 멤버 접근 및 호출

    // ----- 문자열 리터럴과 C 문자열 함수 -----
    const char* msg = "hello";                         // 문자열 리터럴(상수), 포인터 변수 msg
    size_t len = std::strlen(msg);                     // std::strlen: 길이 계산, 함수 호출 연산자 ()

    // ----- 네임스페이스 범위 연산자(::) -----
    std::cout << "PI=" << PI << ", E=" << E << "\n";   // ::로 std 이름공간 사용, <<로 출력 연결

    // ----- 매크로 함수 사용 -----
    int nine = SQR(3);                                 // 전처리 매크로 SQR 전개: ((3)*(3)) → 9

    // ----- enum class와 비트 플래그처럼 사용 -----
    Color c = Color::RED;                              // enum class 상수(식별자 c)
    bool is_red = (static_cast<int>(c) & 0x1) != 0;    // 정수로 변환 후 비트 AND, 비교 연산

    // ----- 콤마(,) 연산자 -----
    int k = 0;                                         // 변수 k 선언/초기화
    int r = (k = 5, k + 2);                            // 콤마 연산자: 왼쪽부터 평가, 마지막 값(k+2)이 r에 대입

    // ----- 참조(레퍼런스) -----
    int& ref = a;                                      // 참조자 ref는 a의 별칭 — &는 선언 맥락에서 참조 의미
    ref += 10;                                         // ref를 수정하면 a가 함께 변경

    // ----- 동적 메모리(new/delete)와 포인터 -----
    int* dyn = new int(123);                           // new: 동적 할당 및 값 초기화
    int dyn_val = *dyn;                                // 역참조하여 값 읽기
    delete dyn;                                        // delete: 동적 메모리 해제(대응하는 delete 필수)

    // ----- 디버그 매크로 호출(조건부로만 출력) -----
    DBG("a=" << a << ", b=" << b);                     // DEBUG 정의 여부에 따라 출력/무시

    // ----- 출력: 결과 몇 가지 확인 -----
    std::cout << "sum=" << sum
              << ", rem=" << rem
              << ", l2=" << l2
              << ", nine=" << nine
              << ", len(" << msg << ")=" << len
              << ", bigger=" << bigger
              << ", r=" << r
              << "\n";                                 // 여러 값들을 <<로 연결하여 한 줄 출력

    // ----- 전역 변수 접근 및 증가 -----
    ::global_counter++;                                // 범위 지정(::)으로 전역 식별자 참조, 후위 증가 연산자++

    return 0;                                          // 반환문 — 0은 정상 종료를 의미하는 정수 상수
}                                                      // main 종료

// ===================== 함수 정의(식별자 add) =====================

int add(int a, int b) {            // 함수 정의: 식별자 add, 매개변수 a/b
    return a + b;                  // 산술 +, return으로 결과 반환
}                                   // 함수 종료

---

포인트 요약

• 전처리기: #include, #define, 조건부 컴파일 #ifdef/#else/#endif와 매크로 함수/상수 사용.
• 식별자: 타입 이름(Vec2, Color, i32), 변수/함수/멤버/열거 상수/매크로 이름 전반.
• 상수: 리터럴(정수, 실수, 문자, 문자열, 불리언), const, constexpr, enum class 상수.
• 자료형: 기본형(int, double, char, bool, unsigned), 포인터/참조, 배열, 구조체, 별칭(using), size_t.
• 변수: 전역/지역/포인터/참조/배열/구조체 인스턴스 등 다양한 선언과 초기화.
• 연산자:
  • 산술: + - * / %
  • 대입/복합대입: = += *=
  • 비교: == != < >=
  • 논리: && || !
  • 비트: & | ^ ~ << >>
  • 기타: ?: sizeof & * . -> [] :: , ++
  • 형변환: static_cast<T>(expr)