프로그래밍 공부 이야기

c++ 클래스

샤샤샤샤 — Wed, 12 Nov 2025 22:01:35 +0900

c++ 은 클래스를 지원한다. 클래스는 쉽게 말해 함수와 변수를 담고 있는 객체다.

분할 컴파일
c++은 분할 컴파일을 지원한다. 같은 클래스를 여러개의 파일로 관리할 수 있다.
#include "클래스이름"
과 같이 적으면, 해당 파일은 이 클래스에 종속된다.
따라서 헤더 파일에는 클래스의 선언만 하고, 소스 파일에 함수, 변수 등을 선언하는 방식으로 사용 가능하다.

클래스의 컴파일
헤더 파일은 단 한번 컴파일로 모든 헤더 파일을 컴파일하게 된다.
즉 만약 내가 A라는 헤더파일을 만들고 B라는 헤더파일을 만들었다고 가정해보자. 이때 나는 두개의 클래스를 각각 include 할 필요가 없다. 하나만 include 해도 나머지 역시 자동으로 컴파일되기 때문이다.

#pragma once
컴파일시 한번만 정의되도록 한다.

추상화
함수의 선언과 실제 구현을 구분할 수 있다.

//A.h 파일

#pragma once
class A {
public:
    void out();
};

// AFunc.cpp파일
#include "A.h"
#include <iostream>
    void A::out() {
	    std::cout << "A입니다.";

    }

// main코드

#include "A.h"

using namespace std;


int main() {
	A a;
	a.out();

}

c++ 함수2

샤샤샤샤 — Wed, 12 Nov 2025 21:34:09 +0900

인라인 함수
컴파일시, 함수가 저장된 메모리 주소를 가르키는 것이 아닌, 함수 자체가 해당 부분에 삽입되도록 하는 함수다. 즉, 프로그램이 실행되며 메모리 주소 00001 에서 a라는 함수를 호출할때, a가 저장된 01000 으로 이동하는 대신, 컴파일 시점에 00001의 a호출 부분에 아예 a함수를 삽입해버리는 것이다. 그러면 00001에서 01000 으로 이동하는 대신, 그냥 순서대로 코드를 실행시키면 된다.
인라인 함수는 성능 향상의 이점이 있지만 함수가 간단하면 차이는 미미하다.

#include <iostream>

using namespace std;

inline int func(int);

int main() {
    cout << func(5);
}

int func(int a) {
    return a*a;
}

함수 선언 앞에 inline을 붙여 만들수 있다.

디폴트 매개변수
매개변수의 기본값을 지정해준다. 매개변수가 들어오지 않을때 해당 값이 매개변수로 인식된다.

#include <iostream>

using namespace std;

 int func(int a = 3);

int main() {
    cout << func() << std::endl; // 9
    cout << func(5) << std::endl;  // 25
}

int func(int a) {
    return a*a;
}

디폴트 매개변수는 함수의 선언 시점에 매개변수 이름을 정의해주며 값을 넣어주면 된다.
디폴트 매개변수는 여러 매개변수의 가장 오른쪽에 선언해야 한다.

참조 변수
c++ 에서 새롭게 도입한 변수. 참조 변수를 사용하면 함수 내부에서 구조체를 사용해도 복사본이 아닌 원본을 가르키게 된다. 일찍이 사용한 주소 연산자 & 를 사용한다. 즉, &는 코드 문맥에 따라 주소연산자가 되거나 참조연산자가 된다.

#include <iostream>

using namespace std;

 void funcA(int* a, int* b);
 void funcB(int& a, int& b);
 void funcC(int, int);

int main() {
    int a1 = 100;
    int b1 = 200;

    cout << "처음: " << endl;
    cout << "a1: " << a1 << ", b1: " << b1 << endl;
    cout << endl;
    cout << "포인터를 이용한 값 교환" << endl;
    funcA(&a1, &b1);
    cout << "포인터를 이용한 값 교환한 뒤:" << endl;
    cout << "a1: " << a1 << ", b1: " << b1 << endl;
    cout << endl;
    cout << "참조를 이용한 값 교환" << endl;
    funcB(a1, b1);
    cout << "참조를 이용한 값 교환한 뒤:" << endl;
    cout << "a1: " << a1 << ", b1: " << b1 << endl;
    cout << endl;
    cout << "값 이용한 값 교환" << endl;
    funcC(a1, b1);
    cout << "값 이용한 값 교환한 뒤:" << endl;
    cout << "a1: " << a1 << ", b1: " << b1 << endl;
}

// 포인터로 전달
 void  funcA(int* a, int* b){
     int temp;
     temp = *a;
     *a = *b;
     *b = temp;
}


 // 참조로 전달
 void funcB(int& a, int& b) {
     int temp;
     temp = a;
     a = b;
     b = temp;
 }

 // 값으로 전달
 void funcC(int a, int b) {
     int temp;
     temp = a;
     a = b;
     b = temp;
 }

두 매개변수 값을 바꾸는 함수다. 이를 실행한 결과는 다음과 같다.

이때 처음 포인터를 이용해서 값이 바뀌었고, 이후 다시 참조를 이용해서 값이 다시 바뀌었다.
반면 값을 매개변수로 받은 함수는, 함수 내부에서 복사본을 만들어 사용하기 때문에 값이 그대로인 것을 볼 수 있다.
따라서 함수 내부에서 원본에 접근하고자 하면, 참조변수, 또는 포인터를 매개변수로 받아야 한다.

함수의 오버로딩
매개변수를 달리해서 같은 이름의 함수를 여러개 만드는 기능. 이때 매개변수는 같지만 리턴값이 다른 두 함수로 오버로딩하는 것 역시 안된다.

함수의 템플릿
c++ 은 템플릿이라는 기능을 제공한다. 다른 언어의 제네릭과 비슷한 개념으로, 매개변수 타입을 미리 지정해두지 않고, 런타임에 들어오는 형식에 맞게 지정되는 기능이다.
아래의 코드를 보자.

#include <iostream>

using namespace std;

template <class ANY>
ANY sum(ANY, ANY);

int main() {
    int a = 100;
    int b = 200;

    float aFloat = 1.1;
    float bFloat = 2.1;

    cout << sum(a, b) << endl;  // 300
    cout << sum(aFloat, bFloat);  // 3.2
}

template <class ANY>
ANY  sum(ANY a, ANY b){
     return a + b;
}

하나의 함수가 각기 다른 타입의 매개변수를 받아, 각기 다른 타입의 결과를 리턴한다.
다만 이때 하나 주의할건, ANY는 하나의 타입만 될 수 있다는 거다. 아래와 같은 코드는 불가능하다.

#include <iostream>

using namespace std;

template <class ANY>
ANY sum(ANY, ANY);

int main() {
    int a = 100;

    float aFloat = 1.1;

    cout << sum(a, aFloat) << endl;
}

template <class ANY>
ANY  sum(ANY a, ANY b){
     return a + b;
}

c++ 함수

샤샤샤샤 — Mon, 10 Nov 2025 22:21:44 +0900

c++ 는 컴파일러가 main을 가장 마지막에 컴파일 하지 않는다. 따라서 main에서 사용된 함수가 main 아래에서 선언된 경우, 컴파일 되지 않은 함수를 인식하지 못해 오류가 발생한다.

#include <iostream>

using namespace std;

int main()
{
	hello();
}

void hello() {
	cout << "hello world";
}

이때 hello 는 main아래에 있어서 컴파일 시점에 오류가 발생한다.

이를 막기 위해 함수 선언만 main위에 먼저 하고, 아래에서 다시 구현할 수 있다.

void hello();

int main()
{
	hello();
}

void hello() {
	cout << "hello world";
}

파라미터와 전달 인자
함수를 호출할때 전달되는 값이 전달 인자, 함수 내부에서 사용되는 변수가 파라미터다. 전달인자란 실제 값, 파라미터는 함수 내부 변수라고 이해하면 편하다.

#include <iostream>

using namespace std;

void hello(int);

int main()
{
	hello(3);
}

void hello(int n) {
	cout << "hello world: " << n ;
}

함수의 선언에서는 파라미터의 이름을 생략해도 문제가 없다.

함수와 배열

함수는 배열을 직접 return 해줄수 없다.

함수와 구조체
함수는 내부에서 구조체를 직접 파라미터로 받을수도 있고, 직접 구조체를 return할수도 있다. 그러나 이때 복사본을 만들어서 이로 작업하기 때문에 메모리를 많이 소모하게 되고, 복사 시간도 오래 걸리게 된다.
이를 피하기 위해서는 아래와 같이 값이 아니라 메모리 주소(포인터) 로 넘길수 있다.

#include <iostream>

using namespace std;

struct Human {
    int age;
};

void increaseAge(Human* h) {  // 포인터로 전달
    h->age += 1;              // 원본에 직접 접근
}

int main() {
    Human person;
    person.age = 20;

    increaseAge(&person);     // 주소 전달
    cout << person.age << endl;  
}

함수와 포인터
함수 역시 특정 메모리에 저장되며, 메모리 주소를 가지고 있다. 따라서 포인터 변수에 함수를 담을 수 있다.

#include <iostream>

using namespace std;

string func(string);

int main() {
    string(*p)(string);
    p = func;
    cout << (*p)("hello");
}

string func(string a) {
    return a;
}

이때 string(*p)(string); 은 함수의 포인터가 된다. 앞에서 부터 분석해보면 string을 반환값으로 받으며 p라는 이름의 * 포인터인, (string) 을 매개변수로 받는, 함수의 포인터라는 의미다.
그리고 이 포인터를 함수처럼 호출하는 것이 바로 (*p)("hello"); 인 것이다.

c++ 포인터

샤샤샤샤 — Sun, 9 Nov 2025 15:33:34 +0900

포인터
모든 변수는 메모리의 특정 주소에 저장된다. 주소는 다음과 같이 알 수 있다.

#include <iostream>

int main()
{
    int x;
    std::cin >> x;
    std::cout << &x;
}

앞에 &를 붙이면 알 수 있다.
다만 이렇게 하려면, 반드시 값변수를 선언해야 한다. 먼저 값 변수를 선언하지 않고, 메모리 주소로 선언하는 변수가 바로 포인터다.
포인터는 다음과 같이 선언 가능하다.

#include <iostream>

int main()
{
    int x = 3;
    int* y = &x;
    int *z = y;
    std::cout << y << std::endl; // 실제 y의 주소
    std::cout << *y << std::endl; // y의 값
    std::cout << z << std::endl; 
    std::cout << *z << std::endl; 

}

*를 띄어쓰기 하고 붙이거나, 그냥 바로 붙여도 상관없다.
실제 해당 메모리 주소가 표현하는 값을 알고 싶으면 변수명 앞에 *를 붙이면 된다.

포인터는 배열로 선언할 수도 있다.
이때 배열 내부 요소들은 해당 값들의 주소를 가르키게 되며, 배열 포인터 자체는 첫번째 요소를 가르킨다.

using namespace std;

int main()
{
	int arr[3] = { 10, 20, 30 };
	int* x = arr;

	cout << *x << endl;     // 10
	cout << *(x + 1) << endl; // 20
	cout << *(x + 2) << endl; // 30
}

이때 다음과 같이 출력해보자.

using namespace std;

int main()
{
	int arr[3] = { 10, 20, 30 };
	int* x = arr;
	x = x + 1;

	cout << *x << endl;     // 20
	cout << *(x + 1) << endl; // 30
	cout << *(x + 2) << endl; // 의미없는 값
}

x+1의 의미는 배열을 메모리 주소를 한칸 뒤로 옮긴다는 것이다. 따라서 x의 첫번째 요소가 20, 두번째 요소가 30이 되고, 3번째 요소는 그 뒤의 메모리, 즉 뭔지 모를 값이 나오게 된다.

포인터의 활용 new

객체지향언어는 실행 시간에 동적으로 메모리를 할당받을 수 있다는 장점이 있다. 그리고 이렇게 동적으로 변하는 메모리를 다루는 도구가 포인터다.
구조체 역시 포인터로 생성 가능하며, 이때 new 예약어를 사용해야 한다.

#include <iostream>

using namespace std;

struct Human { // 구조체 생성
	int age;
	char name[20]; 
};

int main()
{
	Human* human = new Human; // 포인터로 구조체 Human형식의 변수 생성

	cout << "나이를 입력하세요";
	cin >> human -> age; // 구조체 내부의 변수에 값 할당

	cout << "이름을 입력하세요";
	cin >> (*human).name; // 구조체 내부의 변수에 값 할당. -> 와 같은 동작

	cout << "이름은 " << human->name << "입니다.";
}

이렇게 new로 포인터 변수를 사용했으면 이제 메모리를 해제해줘야 한다. 더이상 사용하지 않아 메모리 공간을 낭비하고 싶지 않으면, 포인터를 삭제해줘야 한다. 배열 역시 한번의 delete[] 함수로 해제가 가능하다.

#include <iostream>

using namespace std;

struct Human {
	int age;
	char name[20];  // 문자열을 직접 가리키는 포인터
};

int main()
{
	Human* human = new Human;

	cout << "나이를 입력하세요";
	cin >> human -> age;

	cout << "이름을 입력하세요";
	cin >> (*human).name;

	cout << "이름은 " << human->name << "입니다.";
	delete human;
	cout << "이름은 " << human->name << "입니다.";
}

위의 코드는 delete 이후의 human->name 에서 에러가 발생한다. human 의 포인터가 삭제되면서, human 의 메모리 주소가 아무것도 없기 때문이다.

c++ 기본 문법

샤샤샤샤 — Sun, 9 Nov 2025 13:54:44 +0900

기본 자료형

1) char : 문자 한글자를 담는 자료형. 기본 1바이트다.
2) short : 2바이트의 정수를 담을 수 있는 자료형. 2^16 만큼 표현 가능하다.
3) int : 4바이트의 정수를 담을 수 있는 자료형. 2^32 만큼 표현 가능하다.
4) long(long long int) : 8바이트를 담을수 있는 자료형. 2^64 까지 표현 가능하다. 본래 long long int 이니 long으로 줄여서 표현한다.
5) float: 4바이트. 소수를 담을수 있다. 소수점 7자리까지 정확하게 표현 가능하다.
6) double: 8바이트. 소수를 담을수 있다. 소수점 15~16 자리까지 정확하게 표현 가능하다.
7) bool : 1바이트. 0과 1만 표현 가능하며, 0은 false, 1은 true 를 의미한다.

전처리기 지시문
컴파일 전에 다른 파일을 포함시키기 위한 분법. 코드 상단에 #include <라이브러리 이름> 과 같이 사용한다. 컴파일 과정을 거치기 전, 컴파일러가 알아서 해당 파일을 불러와 컴파일 소스 상단에 해당 라이브러리의 소스를 붙여넣는다.

네임스페이스
쉽게 말하자면 함수, 변수, 열거체 등의 이름이 존재하는 모든 것에 대해, 꼬리표를 다는 것이라고 생각하면 편하다.
예를 들면 다음과 같다.
a라이브러리의 out() 함수와 b 라이브러리의 out() 함수의 이름이 같아서 서로 충돌하는 상황이 발생할 수도 있다. 이를 막기 위해 a의 out()을 호출한다, 와 같이 명확한 명시가 필요하다.
이것이 바로 namespace다. a::out()와 같이 호출하면 a의 out()함수를 호출한다.
그러나 이름이 충돌하지도 않는데, 매번 이렇게 적어주는건 불필요하게 코드만 길어지고 개발자의 수고만 늘게 된다. 이를 막기 위해 상단 전처리기 지시문 아래에 using namespace a; 와 같이 적어서 전역적으로 사용 가능하다.

main 함수
프로그램의 시작점. 기본적으로 c++ 코드는 main에서 실행된다. 따라서 프로젝트 1개는 1개의 main함수를 가질수 있다.

입출력
출력은 cout() 함수를 통해 가능하다. 이때 hello world 를 출력한다고 하면, cout("hello world") 가 아니다.
입출력 함수는 비트 연산자 << 와 >> 를 내부적으로 오버로딩하고 있기에, 이를 통해서 출력해야 한다.

#include <iostream>

int main()
{
    std::cout << "Hello World!";
}

이때 << 는 뒤의 문자(문자열)을 출력하라는 의미가 된다. 본래 <<는 비트 하나만큼 옆으로 움직이라는 의미나, 입출력 함수에서는 출력, 입력받으라는 의미가 된다.
따라서 입출력은 아래와 같이 해야한다.

#include <iostream>

int main()
{
    int x;
    std::cin >> x;
    std::cout << x;
}

char[] 와 같은 문자 배열을 출력할때, 빈 값을 만나야만 출력이 멈춘다. 따라서 char[] 형을 출력하고자 하면 배열의 마지막 요소에 빈 값을 의미하는 \0 을 명시적으로 넣어줘야 한다. 않그러면 \0을 만날때까지 계속 메모리를 읽는다.

오픈미션 미션 정하기

샤샤샤샤 — Sun, 9 Nov 2025 12:39:12 +0900

이번 미션에서는 자유 주제다. 아무거나 자신의 한계를 도전해볼만한 주제를 정해서 과제를 수행해서 결과물을 제출해야 한다. 일정은 최대 3주.

내가 고려한 주제는 다음과 같다.

1. 내가 원하는 커스텀 AI 만들기
2. 나만의 언어 새롭게 만들기
3. 톰캣같은 서버 구축하기
4. jvm 커스텀하여 내가 원하는 문법 추가하기

1번은 너무 비현실적인 목표라고 생각했다. ai를 학습시킬 방법이 없을 뿐더러, RAG만 올리는 것은 내 목표와 다르고 너무 쉽기 때문이다. 3번은 반대로 너무 난이도가 높다고 생각해서 포기했다. 나는 최대한 외부 라이브러리를 사용하지 않고 저수준까지 내가 구현하는 방식으로 만들고 싶은데, 3주 안에 할 분량이 아니라고 판단이 되었다. 4번은 단순 구현은 너무 간단하고, 깊게 들어가려면 너무 어려워서 패스했다.

그래서 2번, 나만의 언어 만들기를 목표로 설정했다. 최대한 라이브러리를 사용하지 않고, 과제 코드가 돌아갈만한 수준의 언어를 만드는 것은 충분히 어렵고 아슬아슬하게 할만한 목표라고 판단했다. 구현 언어는 자바 대신 c++로 정했다. 자바 인터프리터가 c와 c++로 이뤄진 만큼, 나역시 c++ 로 구현하는게 좋을것 같았다. 문제는 내가 c++에 대해 아는게 하나도 없다는것.

판다코딩님의 유튜브 강의를 보며 공부한 다음, 이를 바탕으로 구현할 예정이다.

https://www.youtube.com/watch?v=GqhZ5_RtNpQ&list=PLgqG2uj21HgkcfVtlr5rPekQl5VWJEnIB&index=1

C# - 디버깅 포인트가 제대로 안잡히고 함수를 스킵하는 문제

샤샤샤샤 — Fri, 13 Dec 2024 23:52:51 +0900

상황:
디버깅 포인트를 설정하고 디버깅을 시도했을때, 디버깅 포인트에서 실행이 멈추지 않고 스킵되거나 변수가 안잡히고 최적화되는 문제

원인:
Debug 모드가 아닌 Release 모드로 실행했음.

해결:
Debug 모드로 디버깅.

네트워크 경로와 가상 디렉토리

샤샤샤샤 — Wed, 11 Dec 2024 21:15:01 +0900

네트워크 경로
네트워크를 통해서 접근 가능한 경로를 말한다.
\\서버이름\공유이름\폴더 와 같이 표기하며, 이때 실제 경로는 해당 서버 -> 공유 이름 폴더 -> 폴더 로 이어진다.
이때 해당 네트워크 경로로 접근 가능한 사용자는 윈도우의 특정 사용자 또는 그룹으로 지정 가능하다.

가상 디렉토리
실제 파일 시스템의 폴더를 서버에서 다른 경로로 지정하는 기능이다.
D:/서버 폴더/data 라는 디렉토리가 있다고 가정하자. 원래라면 서버가 작동하는 컴퓨터 내부에 서버 폴더가 있고, 그 하위에 data 라는 폴더가 있을 것이다.
이때 data 를 가상 디렉토리로 설정하여 C:/새폴더 로 매칭시키면, 서버가 자신 하위의 /data 로 접근할때, 실제로는 /data가 진짜 매칭된 위치, 즉 C드라이브 내부의 새폴더로 매칭되는 것이다.
IIS 에서는 편하게 이를 사용하기 위해 가상 디렉토리를 간단하게 생성할 수 있는 기능을 지원한다.

따라서 앞서 말한 네트워크 경로를 이용하여 웹 서버와 파일 서버를 분리하는 식으로 활용할수 있다.

이때 웹 서버와 파일 서버는 액티브 디렉토리(Active Directory) 로 관리되고 있고 같은 도메인에 속해있거나, 아니면 아이디와 비밀번호가 같으면 접근이 가능하다.

즉, 두 컴퓨터 모두 계정 id가 test 이고 비밀번호가 1234 이면 네트워크 경로를 통해 접근이 가능하다는 것이다. 따라서 네트워크 경로를 사용한다면 보안에 엄격한 주의가 필요하다.

ASP.NET 에러 - '~'의 형식 이니셜라이저에서 예외를 Throw 했습니다.

샤샤샤샤 — Wed, 11 Dec 2024 20:56:07 +0900

1. 상황
로컬에서는 문제없이 돌아가던 코드가 배포환경에서 오류가 발생

2. 원인
web.config 또는 app.config 파일에서 가져오는 외부 변수가 정의되지 않음.

 <add key="키이름" value="값" />

이런 식으로 코드 내부에서 가져다가 사용하는데, 배포 과정에서 해당 문구가 빠지게됨

3. 해결
app.config에 변수 정의

SVN 커밋 에러 - [xxx] is not under version control출처:

샤샤샤샤 — Tue, 3 Dec 2024 21:26:39 +0900

상황:
파일을 커밋하려고 하는데 해당 문구가 나오면서 커밋이 안됨

원인:
상위폴더가 커밋되지 않은 상태에서 하위폴더 커밋 시도.
또는 커밋이 그냥 꼬임

해결:
1. 상위 폴더와 하위 폴더를 같이, 또는 순서에 맞춰 커밋한다.
2. 커밋이 꼬였으니 svn을 끊었다가 다시 연결한다.
- 1. 프로젝트 -> 우클릭 -> Team -> Disconnect
- 2. also delete meta data ... 이런 문구가 적힌 옵션 클릭. svn 메타 데이터도 삭제하는 옵션이다.
- 3. svn add/ 또는 프로젝트 -> 우클릭 -> Team -> Share Project 를 통해 다시 svn 연결