본문으로 건너뛰기

캠프 7일차

O-h-y-o26. 7. 6.약 11 분CampUnreal

캠프 7일차

C++

Hello World

#include <iostream> // i는 input, o는 output
// cpp에서 제공하는 헤더파일은 <> 를 통해 불러오고, 사용자 정의 헤더 파일은 "" 를 통해 불러온다.

using namespace std;

int main() { // cpp이 시작되면 main을 제일 먼저 찾고 실행한다. (시작점/진입점)
    cout << "Hello, World!" << endl; // using namespace std; 가 없으면 std::cout 이런식으로 작성해야한다.
    // cout → console output
    // endl → end line (개행 - 한 줄 띄기)
    return 0;
}

변수

변수 선언
#include <iostream>
#include <string> //string 헤더를 추가, c++에서 편하게 쓰라고 만들어줌
using namespace std;

int main() {
    // 정수형 변수 선언
    int age = 25;  // 초기값 25
    int year;      // 초기값 없음

    // 실수형 변수 선언
    float pi = 3.14f;
    double largeDecimal = 12345.6789;

    // 문자형 변수 선언
    char grade = 'A';

    // 문자열 변수 (C++ 표준 라이브러리 사용)
    string name = "John";

    // 불리언 변수
    bool isStudent = true;

    cout << "Age: " << age << endl;
    cout << "Year: " << year << " (uninitialized, may contain garbage value)" << endl;
    cout << "Pi: " << pi << endl;
    cout << "Large Decimal: " << largeDecimal << endl;
    cout << "Grade: " << grade << endl;
    cout << "Name: " << name << endl;
    cout << "Is Student: " << (isStudent ? "true" : "false") << endl;

    // const - 상수 선언 → Read only가 된다. 수정 불가능.
    const double gravity = 9.8;  // 중력 가속도
    cout << "Gravity: " << gravity << endl;

    return 0;
}

배열

선언
#include <iostream>
using namespace std;

int main() {
    // 선언과 동시에 초기화
    int arr1[3] = {1, 2, 3};

    // 선언 후 개별 원소 초기화
    int arr2[3];
    arr2[0] = 10;
    arr2[1] = 20;
    arr2[2] = 30;

    // 배열 출력
    cout << "arr1: " << arr1[0] << ", " << arr1[1] << ", " << arr1[2] << endl; // → arr1: 1, 2, 3
    cout << "arr2: " << arr2[0] << ", " << arr2[1] << ", " << arr2[2] << endl; // → arr2: 10, 20, 30

    return 0;
}

반복을 줄이는 함수

기본 함수 정의와 호출
#include <iostream>
using namespace std;

// 두 정수를 더하는 함수
int add(int a, int b) {
    return a + b; // 결과 반환
}

int main() {
    int result = add(3, 7);
    cout << "3 + 7 = " << result << endl; // 출력: 3 + 7 = 10
    return 0;
}

값의 변화

일반 변수
#include <iostream>
using namespace std;

// 함수: 값 전달 (Call by Value)
void modifyValue(int x) {
    x = 100;  // 함수 내부에서 값 변경
}

int main() {
    int num = 50;
    modifyValue(num); // 값 전달 (복사됨)

    cout << "값 전달 후 num: " << num << endl;
    // 출력: 값 전달 후 num: 50
    return 0;
}

기타 함수 예제

원의 넓이 계산
#include <iostream>
using namespace std;

/**
 * @brief 반지름을 입력받아 원의 넓이를 계산하는 함수
 * @param radius 원의 반지름
 * @return double 원의 넓이
 */
double calculateCircleArea(double radius) {
    return 3.14 * radius * radius;
}

int main() {
    double radius = 5.0;
    cout << "원의 넓이: " << calculateCircleArea(radius) << endl;
    return 0;
}

조건문

단순 if문
#include <iostream>
using namespace std;

int main() {
    int age;

    cout << "Enter your age: ";
    cin >> age;

    // if 문: 조건이 true일 때만 실행
    if (age >= 18) {
        cout << "You are eligible to vote." << endl;
    }

    // 조건이 false인 경우 아무것도 실행안됨
    cout << "Program finished." << endl;

    return 0;
}

잘 작성된 조건문과 아닌 조건문

잘 작성된 조건문

잘 작성된 조건문의 경우 한 눈에 보기에도 깔끔하다.

#include <iostream>
using namespace std;

int main() {
    char op;
    double num1, num2;

    cout << "Enter first number: ";
    cin >> num1;
    cout << "Enter an operator (+, -, *, /): ";
    cin >> op;
    cout << "Enter second number: ";
    cin >> num2;

    if (op == '+') {
        cout << "Result: " << num1 + num2 << endl;
    }
    else if (op == '-') {
        cout << "Result: " << num1 - num2 << endl;
    }
    else if (op == '*') {
        cout << "Result: " << num1 * num2 << endl;
    }
    else if (op == '/') {
        if (num2 == 0) {
            cout << "Division by zero is not allowed." << endl;
        } else {
            cout << "Result: " << num1 / num2 << endl;
        }
    }
    else {
        cout << "Invalid operator." << endl;
    }

    return 0;
}

반복문

for

1부터 10까지 합
#include <iostream>
using namespace std;

int main() {
    int sum = 0; // 합을 저장할 변수 초기화
    for (int i = 1; i <= 10; i++) { // 초기화: i = 1
                                    // 종료 조건: i <= 10
                                    // 사후 동작: i++
        sum += i; // 실제 동작: sum에 i를 더함
    }
    cout << "Sum: " << sum << endl; // Sum: 55
    return 0;
}

while

사용자 입력 종료
#include <iostream>
using namespace std;

int main() {
    int number; // 사용자 입력값을 저장할 변수

    cout << "Enter numbers (negative number to stop): ";
    cin >> number; // 초기 동작: 첫 번째 입력 받기

    while (number >= 0) { // 종료 조건: 입력값이 음수가 아니면 반복
        cout << "You entered: " << number << endl; // 실제 동작: 입력값 출력
        cin >> number; // 사후 동작: 다음 입력 받기
    }

    cout << "Program terminated." << endl;
    // Enter numbers (negative number to stop): 5
    // You entered: 5
    // 10
    // You entered: 10
    // -1
    // Program terminated.
    return 0;
}

포인터

일반적인 변수들이 특정한 값을 담았다면, 포인터는 값을 담는 대신 변수의 주소를 담는다.
그렇다고 포인터가 변수가 아닌것은 아니다. 포인터도 변수이다.
변수는 메모리 공간의 이름이다. 이 메모리의 주소값을 알면 해당 공간을 직접 제어할 수 있다.

기본 변수
#include <iostream>
using namespace std;

int main() {
    int a = 10;   // 4바이트 크기의 변수
    int b = a;    // 변수 a의 값을 b에 복사 (4바이트 비용 발생)

    cout << "a: " << a << ", b: " << b << endl;

    b = 20; // b의 값만 변경

    cout << "변경 후 a: " << a << ", b: " << b << endl;

    return 0;
}

일반 변수의 경우 값의 복사 비용이 크지 않지만, 배열의 경우 복사 비용이 엄청 커질 수 있기 때문에 배열은 A = B 처럼 일반적으로 복사가 불가능하다.
이처럼, '효율적으로 접근할 수 없을까' 에 대해서 고안되어 나온 것이 포인터이다. 포인터는 int* a; 처럼 *(Asterisk, 에스테르크)를 써서 정의해준다.

#include <iostream>
using namespace std;

int main() {
    int a = 10;
    int* p = &a; // 변수 a의 주소를 포인터 p에 저장

    cout << "변수 a의 값: " << a << endl; // 10
    cout << "변수 a의 주소: " << &a << endl; // 실행시마다 다름
    cout << "포인터 p의 값(저장된 주소): " << p << endl; // 변수 a의 주소와 같다.

    return 0;
}

포인터 변수 구성 요소

배열 접근

배열 이름은 배열의 시작주소를 담는다.

#include <iostream>
using namespace std;

int main() {
    int arr[3] = {10, 20, 30};
    int* p = arr; // 배열의 시작 주소를 포인터에 저장

    cout << "p가 가리키는 값: " << *p << endl; // 10
    cout << "p+1이 가리키는 값: " << *(p + 1) << endl; // 20
    cout << "p+2이 가리키는 값: " << *(p + 2) << endl; // 30

    return 0;
}

포인터 역참조

포인터를 활용하려면 해당 주소에 있는 실제 값을 읽고 수정할 수 있어야한다.
포인터는 주소를 다루는 특성 때문에 산술 연산 역시 주소를 제어하는 방식으로 동작한다.
이를 위해 역참조 연산자 *(에스테르크)를 사용한다.

포인터와 변수의 관계
#include <iostream>
using namespace std;

int main() {
    int x = 3;    // 정수형 변수 x 선언
    int* ptr = &x; // 포인터 ptr에 x의 주소 저장

    cout << "x의 값: " << x << endl; // 3
    cout << "x의 주소: " << &x << endl; // 00000004D0CFFCA0
    cout << "ptr의 값(저장된 주소): " << ptr << endl; // 00000004D0CFFCA0
    cout << "*ptr이 가리키는 값: " << *ptr << endl; // 3

    return 0;
}

배열과 포인터

배열은 변수의 기본적인 특성 + 다음의 특징이 있다.

  • 배열 이름은 배열의 시작 주소를 가지고 있다.
  • 값을 저장할 수 있다.
  • 인덱스를 통한 임의 접근이 가능한 이유는 배열의 메모리가 연속적으로 할당되기 때문이다.
  • 임의 접근이 가능하려면 배열 이름에 저장된, 배열의 시작 주소를 알아야한다.
  • 배열 자체가 담고 있는 시작 주소를 변경할 수 없다.

arr[k] = *(arr+k) arr[k] 는 *(arr+k) 와 동일하다.

배열과 포인터는 동일해보이지만, 배열의 이름은 사용될 때 대부분 포인터로 암시적 형 변환되어 동작한다.
in arr[4]; 가 있을때 arr 는 배열 전체를 의미한다. 식이나 인자로 사용될때는 int* 형으로 변환되어 배열의 첫 번째 원소 주소로 해석된다.

배열의 기본 개념과 인덱스 접근
#include <iostream>
using namespace std;

int main() {
    int arr[5] = {10, 20, 30, 40, 50}; // 크기가 5인 배열 선언 및 초기화

    // 배열 요소 접근 (인덱스를 이용한 접근)
    cout << "arr[0]: " << arr[0] << endl; // 10
    cout << "arr[2]: " << arr[2] << endl; // 30
    cout << "arr[4]: " << arr[4] << endl; // 50

    // 배열의 시작 주소 확인
    cout << "배열의 시작 주소: " << arr << endl;
    cout << "첫 번째 요소의 주소: " << &arr[0] << endl;

    return 0;
}

포인터 배열과 배열 포인터

포인터 배열은 포인터를 원소로 갖는 배열이다.
int* ptrArr[4]; 는 크기가 4이고 각 원소가 int*인 배열이다.

배열 포인터는 배열 전체를 가리키는 포인터이다.
단일 변수가 아닌 배열을 통째로 가리키는 변수다.
보통 다차우너 배열을 제어할 때 많이 사용한다.

포인터 배열 vs 배열 포인터

*ptrArr[1] 과 *(ptrArr + 1)은 같다.
(*ptr)[1] 과 *(*ptr + 1) 은 같다.

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2, z = 3;
    int* ptrArr[3] = { &x, &y, &z }; // 포인터 배열 (각 원소가 int* 타입)

    int arr[3] = { 10, 20, 30 };
    int (*ptr)[3] = &arr; // 배열 포인터 (배열 전체를 가리킴)

    // 포인터 배열을 통한 접근
    cout << "*ptrArr[0]: " << *ptrArr[0] << endl; // 1
    cout << "*ptrArr[1]: " << *ptrArr[1] << endl; // 2
    cout << "*ptrArr[2]: " << *ptrArr[2] << endl; // 3

    // 배열 포인터를 통한 접근
    cout << "(*ptr)[0]: " << (*ptr)[0] << endl; // 10
    cout << "(*ptr)[1]: " << (*ptr)[1] << endl; // 20
    cout << "(*ptr)[2]: " << (*ptr)[2] << endl; // 30

    return 0;
}

포인터 연산

포인터는 주소값을 담기 때문에 산술 연산 시 일반적인 수치 연산이 아닌 메모리 주소의 이동으로 해석된다.
포인터의 타입에 따라, 해당 타입 변수의 크기만큼 담고 있는 주소를 증가시킨다.

ptr + 1 을 실행하면 ptr이 가리키는 주소에서 한 단위 메모리 주소가 이동한다.
한 단위는 포인터 자료형 크기에 따라 결정된다.
int형 ptr이 20일때, ptr + 1 은 24가 된다. double 형이라면 ptr + 1은 28이 된다.

(*ptr) + 1 을 실행하면 ptr이 가리키는 변수의 값을 1 증가시킨다.
ptr이 가리키는 주소의 값이 10이라면, (*ptr + 1) 은 11이 된다.

*(ptr + 1)은 ptr[1] 과 동일하다.
ptr이 가리키는 주소에서 +1 만큼 한 주소의 값이 출력된다.

레퍼런스

포인터를 사용하면 주소값을 직접 다루어야 하기 때문에 복잡해질 수 있다.
이 문제를 완화하기 위해 C++ 에서는 변수에 또 다른 이름을 부여하는 레퍼런스 문법을 도입했다.
레퍼런스는 일반 변수와 거의 동일하게 사용할 수 있다.
내부적으로는 해당 변수를 직접 가리키는 역할을 한다.

레퍼런스는 특정 변수에 대한 별명을 부여하는 것이다.
특정 변수의 레퍼런스를 연결하면, 이후로는 그 변수가 두 개의 이름을 갖는것과 같다.
선언 방법은 데이터형 뒤에 & 를 붙인다.
int& ref = var; 처럼 사용하며 ref의 값이 변경될 시 var의 값도 변경된다.

기본적인 레퍼런스
#include <iostream>
using namespace std;

int main() {
    int var = 10;
    int& ref = var; // var의 레퍼런스 선언

    cout << "초기 값:" << endl;
    cout << "var: " << var << endl; // 10
    cout << "ref: " << ref << endl; // 10

    ref = 20; // ref를 변경하면 var도 변경됨

    cout << "ref 값을 변경한 후:" << endl;
    cout << "var: " << var << endl; // 20
    cout << "ref: " << ref << endl; // 20

    return 0;
}

포인터와 레퍼런스의 차이점

포인터와 레퍼런스는 다른 변수를 제어한다는 점에서 유사하지만, 몇 가지 중요한 차이가 있다.

  1. 선언과 초기화 시점이 다르다.
    • 포인터는 선언 후, 나중에 대입연산자를 통해 가리킬 대상을 변경할 수 있다.
    • 레퍼런스는 선언과 동시에 초기화해야 하며, 초기화 이후에는 다른 대상에 재연결 할 수 없다.
  2. 레퍼런스는 항상 다른 변수와 연결되어 있어야 하기 때문에 NULL 이라는게 없다.
    • 포인터는 유효한 대상이 없음을 나타내기 위해 NULL 혹은 nullptr 을 가질 수 있다.
  3. 간접 참조 문법의 유무
    • 포인터는 주소값을 담으므로 접근할 때는 * 연산을 사용하고 주소를 가져올 때는 & 연산을 사용한다.
    • 레퍼런스는 변수 자체의 별명이므로 일반 변수와 연산하는 방법이 동일하다.
선언 및 초기화 차이
#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 20;

    // 포인터는 선언 후 나중에 다른 변수를 가리킬 수 있음
    int* ptr = &a; // 포인터 선언 및 초기화
    ptr = &b; // 포인터가 다른 변수를 가리킬 수 있음

    // 레퍼런스는 선언과 동시에 초기화해야 함
    int& ref = a;
    // ref = &b; // 레퍼런스는 다른 변수에 재할당할 수 없음

    cout << "포인터 사용:" << endl;
    cout << "*ptr: " << *ptr << endl; // 20 (포인터가 b를 가리키고 있음)

    cout << "레퍼런스 사용:" << endl;
    cout << "ref: " << ref << endl; // 10 (a를 가리키고 있음)

    return 0;
}

상수 레퍼런스

레퍼런스에 상수 제약을 걸어서 읽기 전용으로 사용할 수 있다.
상수 레퍼런스를 사용하면 값을 복사하지 않고도 기존 변수를 보호할 수 있다.

상수 레퍼런스의 기본 개념
#include <iostream>
using namespace std;

int main() {
    int x = 100;
    const int& cref = x; // x를 읽기 전용으로 참조

    cout << "cref: " << cref << endl; // 100

    // cref = 200; // 상수 레퍼런스는 값을 변경할 수 없음

    x = 200; // 원본 변수 x는 변경 가능
    cout << "x 변경 후 cref: " << cref << endl; // 200

    return 0;
}
최근 수정:
기여자: ohyo