SturdyCobble's Study Note

[프로그래밍] 6.6 레퍼런스(Reference)와 포인터(Pointer)

StudyingCobble — Wed, 29 Jul 2020 20:31:05 +0900

이 글은 C++의 레퍼런스에 대해 다룹니다. C/C++의 포인터도 약간 다룹니다.

C++에서 Reference는 Pointer와 같이 변수를 간접적으로 접근할 수 있게 하는 역할을 합니다. 하지만, 그 자체에 메모리 주소를 저장하는 것이 아니라, 하나의 별명을 만드는 것처럼 작동합니다. 사실 포인터를 통해 내부적으로 레퍼런스가 구현될 수 있지만, 레퍼런스 만의 장점이 있어서 종종 이용됩니다.

int var = 10;
int& ref_var = var;

cout<< var << "," << ref_var << endl;
cout<< &var << "," << &ref_var << endl;

위와 같이 &를 이용합니다. 이때, Reference를 만들기 위한 &와, 주소를 가져오는 &가 서로 다르다는 사실에 유의해야 합니다. 레퍼런스의 경우 포인터처럼 *을 이용할 필요도 없습니다. 또한, 원본 변수와 같은 메모리상 주소를 나타내므로, 둘 중에 어느 것을 수정하여도 다른 값이 자동으로 변경되게 됩니다. '별명'이라는 개념으로 이해하면 편합니다.

레퍼런스의 특징은 초기화하지 않으면 에러가 발생한다는 점입니다. 어떻게 보면 당연합니다. 레퍼런스는 기존의 변수와 같은 주소를 가리켜야 하므로, 초기화를 하지 않으면 변수인데 가리키는 주소가 없는 상태가 될테니 말입니다. 따라서 원본 변수와 같은 자료형을 가져야 하는 것은 당연한 이치입니다.

이미 생성된 레퍼런스는 그 가리키는 변수를 변경할 수 없습니다. ref_var = var2이런 식으로 대입하는 것은 가리키는 변수를 바꾸는 것이 아니라 var2가 가지는 값을 대입하는 식이 됩니다. 연장선상에서 생각해보면, 상수또한 대입할 수 없습니다.

포인터와 레퍼런스는 사용되는 장소에 있어서 매우 유사합니다. 다음의 예시는 포인터와 레퍼런스를 함수의 인수와 리턴값으로 활용한 예시들입니다.

# include <iostream>
using namespace std;

void funcReference(int& rf_var) {
  rf_var = rf_var + 10;
}

void funcPointer(int* pt_var) {
  *pt_var = *pt_var + 10;
}

int main(){
  int var0 = 2020;
  funcReference(var0);
  cout << var0 << endl;
  funcPointer(&var0);
  cout << var0 << endl;
  return 0;
}
/*
--------RESULT---------------
2030
2040
*/

레퍼런스를 이용하는 경우 포인터와 다르게 &연산자와 *를 사용할 필요가 없습니다. 하지만, 한 가지 단점은 *같은 것을 붙이지 않기에 헷갈릴 우려도 있습니다. 따라서 이름에 reference임을 같이 표시하면 좋습니다.

# include <iostream>
using namespace std;

int& refFindSmallerOrLeft(int& ref_var1, int&ref_var2) {
  if (ref_var1 > ref_var2) { return ref_var2; }
  else { return ref_var1; }
}

int* ptrFindSmallerOrLeft(int* ptr_var1, int* ptr_var2) {
  if (*ptr_var1 > *ptr_var2) { return ptr_var2; }
  else { return ptr_var1; }
}

int main(){
  int var1 = 2020;
  int var2 = -2020;
  refFindSmallerOrLeft(var1, var2)=-2021;
  cout << var1 << " " << var2 << endl;
  *ptrFindSmallerOrLeft(&var1, &var2)=-2022;
  cout << var1 << " " << var2 << endl;
  return 0;
}
/*
--------RESULT---------------
2020 -2021
2020 -2022
*/

위와 같이 리턴값으로 활용할수도 있습니다. 다만, 지역변수를 반환하려고 하면 다음과 같은 값이 나옵니다.

int& refLocalFood() {
  int localVar = 10;
  return localVar;
}

int* ptrLocalFood() {
  int localVar = 10;
  return &localVar;
}

int main(){
  cout << &refLocalFood() << endl;
  cout << ptrLocalFood() << endl;
  return 0;
}
==============RESULT===================
0
0

실제로 주소가 0이라는게 아니라, 이미 메모리 상에서 사라진 변수이기에 0으로 나타납니다.

포인터와 다르게, 레퍼런스는 포인터나 다시 레퍼런스를 가지지 않습니다. 사실 이렇게 사용할 이유도 별로 없긴 합니다. 다만 포인터의 레퍼런스는 가능합니다. 따라서 이중 포인터를 포인터의 레퍼런스의 형태로 바꾸어 볼 수 있습니다. 이 때, 자료형이 T라고 한다면, 이에 대한 포인터는 T* ptr;로 선언할 것이고, 이에 대한 레퍼런스를 다시 취한다면 T*& ref_ptr;이 됩니다.

void funcThx(char*& var) {
  var="I'm Fine. Thank you. And you?";
}


int main(){
  char* str0 = "How are you?";
  cout << str0 << endl;
  funcThx(str0);
  cout << str0 << endl;
  return 0;
}
/*
--------RESULT---------------
How are you?
I'm Fine. Thank you. And you?
*/

배열이나 함수에 대한 레퍼런스도 가능합니다. 다만 연산자 우선순위에 주의하여야 합니다.

void justFunc(int num) {
  cout << "Num: " << num << endl;
}


int main(){
  int arr[10]={0,1,2,3,4,5,6,7,8,9};
  void (&ref_func)(int)=justFunc;      // NOT  void &ref_func(int)=justFunc
  int (&ref_arr)[10]=arr;
  for(int i=0 ;i<10 ;i++)
    ref_func(ref_arr[i]);
  return 0;
}
/*
--------RESULT---------------
Num: 0
Num: 1
Num: 2
Num: 3
Num: 4
Num: 5
Num: 6
Num: 7
Num: 8
Num: 9
*/

Java나 Python에는 직접적으로 위와 같은 레퍼런스 자료형이 있는 것은 아니지만, 거의 대부분의 자료형이 Reference Type의 형태로 처리됩니다. Java의 경우 일부 Primitive Type을 제외한 자료형이 그렇습니다.

Object o1 = new Object();
Object o2 = o1;

위와 같은 형태로 코드를 작성하면, o1, o2는 객체가 됩니다. 이때, o2=o1이라는 식은 단순히 o1의 값을 대입하는 것을 넘어서 같은 객체를 참조하게 됩니다. C++의 레퍼런스와 매우 비슷하지만, 여기서는 값을 변경할 수 있습니다.

또한, Java의 경우 각 Primitive 자료형(예를 들어 int에 대응하는 Int)에 대응하는 참조 자료형이 존재합니다. 이 부분에 대해서는 다음 글에서 다룰 예정입니다.

Python의 경우도 비슷합니다. 다만, 일반적인 int와 같은 자료형에 대해서는 그 값만을 복사하게 됩니다. 그러나 주소를 복사하는 대표적인 예시가 리스트입니다.

a = [1,2,3,4,5]
b = a
b.append(6)
print(a)
print(b)
-------Result---
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]

다만, int형도 객체로서 처리되므로 다음과 같은 결과가 나오게 됩니다.

sa = [1,2,3,4,5]
sb = sa
sb.append(6)
print(id(sa)==id(sb))
a = 10
b = a
print(id(a)==id(b))
b = b + 11
print(id(a)==id(b))
===================Result===============
True
True
False

즉, 대입되어 값이 같을 때에는 같은 주소를 가리킵니다.

이에 관한 내용은 다른 글에서 다시 다룰 예정입니다. (아니면 이미 다루었을 수도 있습니다.)

다음 글에서는 Java와 Python의 참조 자료형들과 얕은 복사와 깊은 복사, 그리고 Java의 Primitive Type에 대응하는 Wrapper Class에 대해 알아볼 예정입니다. (물론 상황에 따라 내용이 변경될 수 있습니다.)

Atom을 LaTeX 편집기로 활용하기

StudyingCobble — Fri, 10 Apr 2020 13:30:41 +0900

최근 LaTeX을 활용할 일이 많아져서 Atom에 관련 패키지를 설치해서 편집기로 활용할 수 있도록 했습니다. 설치한 패키지는 다음과 같습니다. 물론 그 전까지 Overleaf를 잘 활용하고 있었지만, 인터넷이 되야 한다는 점 등이 걸려서 Atom을 활용하기로 했습니다.

latex -> Compile
language-latex -> Syntax Highlight
latexer -> Auto-complete

LaTeX 조판 프로그램이 추가로 설치되어야 하는데, 처음에는 MikTex 쓰다가 나중에 TexLive로 갈아탔습니다. 둘 다 패키지에 latexmk를 추가해야 하는데, MikTex의 경우 내장 펄(Perl)이 없어서 ActivePerl이나 StrawberryPerl(저는 드라이브 이름때문에 ActivePerl만 사용 가능했습니다.)을 깔아주어야 합니다.

아래 글을 참고하면 될 것 같네요.

https://github.com/thomasjo/atom-latex/wiki/Using-latexmk-with-MiKTeX

근데 자꾸 오류가 났습니다. MikTex를 썼었는데, 자꾸 latexmk가 설치된 걸 인식도 잘 못하길래, 그냥 TexLive로 갈아탔습니다. Setting에서 Tex Path를 바꾸어 주는 것을 잊으면 안 됩니다.

latexmk.exe: The script could not be found.
latexmk.exe: Data: scriptEngine="perl", name="latexmk", path="scripts/latexmk/perl/latexmk.pl"

대강 이런 에러였습니다. 근데 TexLive로 갈아타니 다른 문제가 생겼습니다.

File::Path version 2.08 required--this is only version 1.08 at c:\texlive\2019\texmf-dist\scripts\latexmk\latexmk.pl line 291.
BEGIN failed--compilation aborted at c:\texlive\2019\texmf-dist\scripts\latexmk\latexmk.pl line 291.
C:\texlive\2019\bin\win32\runscript.tlu:910: command failed with exit code 255:
perl.exe c:\texlive\2019\texmf-dist\scripts\latexmk\latexmk.pl -synctex=1 -interaction=nonstopmode -file-line-error -pdf "-outdir="(파일 위치)" "(파일 위치)"

대강 이런 오류였는데, cmd 창에서 latexmk -v를 쳐도 같은 오류가 나는 것을 보아 TexLive쪽 문제인가 싶었지만, 문제는 perl쪽에서 난 것이였습니다.

# File : c:\texlive\2019\texmf-dist\scripts\latexmk\latexmk.pl


use File::Path 2.08 qw( make_path );

문제의 코드는 이거였는데, 저 버전을 낮추니 다른 문제가 생기길레 Perl 쪽 문제인거 같아서 찾아보니까 msys2에도 perl이 있어서 버전을 확인했는데, 저거보다 훨씬 높았습니다... 내장 Perl도 이상이 없었는데, 다른 파일을 뜯어보니 이런 코드가 있었습니다.

-- File : C:\texlive\2019\bin\win32\runscript.tlu


local PERLEXE = try_extern_perl and search_path('perl.exe', PATH)
local extperl_warn
if not PERLEXE then
  if try_extern_perl then extperl_warn = [[
External Perl missing or outdated. Please install a recent Perl, or configure
TeX Live to always use the builtin Perl:
  tlmgr conf texmf TEXLIVE_WINDOWS_TRY_EXTERNAL_PERL 0
Meanwhile, continuing with built-in Perl...
]]

일단 외부에서 먼저 Perl을 찾아오는 코드길레 아래와 같이 바꿔버렸습니다.

local PERLEXE = false

무슨 외부 Perl이 버전이 그렇게 된 건지는 모르겠지만, 일단 무조건 내장 펄을 사용하도록 false를 대입시켰더니 작동합니다. 다만, cmd창에 latexmk -v를 치면 아래와 같이 나오긴 합니다.

C:\Users\user>latexmk -v
External Perl missing or outdated. Please install a recent Perl, or configure
TeX Live to always use the builtin Perl:
  tlmgr conf texmf TEXLIVE_WINDOWS_TRY_EXTERNAL_PERL 0
Meanwhile, continuing with built-in Perl...


Latexmk, John Collins, 26 Dec. 2019. Version 4.67

뭐 작동만 하면 됐습니다.

추가로 pdf-view 패키지도 추가하고, 조그마한 설정을 건드려 결국 다음과 같이 컴파일할 수 있었습니다.

쓰고 보니 뭔가 이상한 문장이지만, 테스트용이니 굳이 수정하진 않았습니다.

[프로그래밍] 6.5 포인터와 배열 (2)

StudyingCobble — Sun, 23 Feb 2020 22:30:37 +0900

※이 글은 프로그래밍 언어에 대한 기초적인 이해를 가정하고 있습니다. 최소 프로그래밍 언어 하나 정도를 약간이라도 접해보시는 것을 추천합니다. 또한, 이 글은 심화 내용은 되도록 피하여 서술했습니다.

이번 글에서는 포인터를 간단하게 활용하고, 연산하는 방법을 알아보겠습니다.

포인터는 기본적으로 주소이므로 숫자를 저장하고 있습니다. 따라서 그냥 덧셈, 뺄셈 다 될 것 같지만, 그렇지 않습니다. 실수로 잘못된 주소를 건드리는 경우가 있을 수도 있기에 주소를 주소로 곱하는 일은 허용되지 않습니다.

비슷한 이유로 사칙연산 중에서 포인터와 숫자 사이 덧셈과 뺄셈, 포인터와 포인터 사이 뺄셈만이 가능합니다. 각 연산의 결과는 다음과 같은 그림으로 표현할 수 있습니다. (물론 포인터 사이에는 타입이 맞아야 합니다.)

보다시피 빼는 경우 둘 사이의 주소상 거리를 나타내는 것이 아니라, 배열에서 거리처럼 T형 포인터는 sizeof(T)를 단위로 하여 측정된 주소상의 거리를 나타내게 됩니다. 포인터와 정수의 덧셈 또한 비슷한 규칙이 적용됩니다. 이 때 유의할 점은 포인터 사이 뺄셈의 결과는 포인터가 아니라 정수라는 점입니다.

만약, 평균이나 3등분점 같은 지점을 찾아야 하는 경우는 어떻게 해야 할까요? 가장 먼저 다음과 같은 코드를 떠올릴 수 있을 것입니다.

int *ptr1 = &num1;
int *ptr2 = &num2;

int *ptrm2 = (ptr1+ptr2)/2
int *ptrm3 = (ptr1+2*ptr2)/3

하지만, 이 경우 포인터와 정수의 나눗셈(또는 곱셈)을 계산해야 해서 문제를 해결할 수 없습니다. 이 경우 정수와 정수의 나눗셈, 정수와 포인터의 덧셈으로 나누어서 생각해볼 수 있습니다.

int *ptr1 = &num1;
int *ptr2 = &num2;

int *ptrm2 = ptr1+(ptr2-ptr1)/2
int *ptrm3 = ptr2+(ptr1-ptr2)/3

포인터의 뺄셈은 정수형의 값을 반환하고, 이를 나누어도 (버림을 한) 정수형 값을 반환하므로 최종적으로 정수와 포인터 사이 덧셈을 수행하게 됩니다.

배열은 포인터와 같이 자주 활용됩니다. 이는 배열의 [ ]의 의미가 단순한 인덱싱 이상으로 활용될 수 있기 때문입니다. 또한, 배열 자체는 다른 언어에서 지원하는 리스트와 같은 자료형과는 다르게 매우 간단해서(때로는 불편하지만) 포인터로서 그 값을 가져올 수도 있습니다. 아래 예시를 참고해봅시다.

int arr[5] = {1,2,3,4,5};
int* ptr = arr;
printf("%d",*ptr);
printf("%d",*(ptr+1));
printf("%d",*(ptr+2));


------------실행 결과----------
123

포인터를 통해 배열의 각 요소에 접근할 수 있음을 확인할 수 있습니다. 여기서 한가지 눈에 띄는 점은 &arr이 아니라 arr을 썼다는 점일 것인데, 이는 배열의 이름 자체가 첫번째 요소의 주소를 저장하기 때문입니다. char* 로 저장한 문자열도, 이와 같은 맥락에서 이해될 수 있습니다.

  char* str = "KOREA";
  char* ptr = str;
  printf("%c",*str);
  printf("%c",str[0]);
  
  ------------실행 결과---------
  KK

여기서 문자열을 저장하기 위해 포인터를 사용한 것은, 저 문자열 자체가 일종의 주소를 나타낸 다는 의미일 것입니다. 실제로, 우리가 사용한 문자열은 특정한 메모리 상 주소에 따로 저장되어 있습니다. 따라서 문자열이 저장된 위치를 가르킨다고 이해할 수 있습니다.

조금만 배열을 활용하면 다음과 같은 예제도 가능합니다.

  int arr[] = {1,2,1024,4096};
  int* ptr = (int*)arr; //나중에 바꾸기 위해서 일부러 불필요한 캐스팅을 남겨두었습니다.
  for(int i = 0; i < sizeof(arr)/sizeof(int); i++){
    printf("%d ",*(ptr+i));
    printf("%d\n",ptr[i]);
  }
  
-----------RESULT--------------
1 1
2 2
1024 1024
4096 4096

포인터와 배열을 같이 사용한 예시입니다. 한번 더 바꾸면 다음같은 예시도 가능합니다.

int arr[] = {1,2,1024,80960};
unsigned short* ptr = (unsigned short*)arr;
for(int i = 0; i < sizeof(arr)/sizeof(short); i++){
    printf("%d ",*(ptr+i));
    printf("%d\n",ptr[i]);
}
------------------RESULT------------------
1 1
0 0
2 2
0 0
1024 1024
0 0
15424 15424
1 1

이 결과는 다음과 같이 값이 저장되어 있음을 암시합니다.

높은 주소부터 숫자가 먼저 채워진다는 점을 확인할 수 있습니다. 좀 더 이해를 돕기 위해 1024와 80960의 케이스를 더욱 확대해보겠습니다.

이렇게 방향을 반대로 생각하면 더 간편하게 이해할 수 있습니다. 이렇게 작은 단위가 주소가 낮은 쪽에 위치하는 방식을 '리틀 엔디안(Little-endian)'이라고 부릅니다. 이 방식은 우리가 읽는 방식과 반대되지만, 작은 단위쪽을 더 쉽게 접근할 수 있습니다. (배열을 생각하면, 배열명이 시작 주소이므로 별도의 덧셈 없이 바로 가장 작은 단위쪽의 수를 가져올 수 있습니다.)

반대로, 큰 단위가 주소가 낮은 쪽에 위치하는 방식인 '빅 엔디안(Big-endian)' 방식은 직관적으로 이해하기가 쉽습니다. (우리가 왼쪽에서 오른쪽으로 글자를 쓰고, 숫자를 적을 때 큰 단위(1234에서는 천 단위부터) 시작하기 때문일 것입니다.) 이러한 방식은 CPU에 따라 달라지며, 인텔 계열의 경우 리틀 엔디안을 사용한다고 합니다.

배열에서 하나씩 값을 불러오는 경우를 다음과 같은 코드를 사용할 수 있습니다.

  int arr[] = {0,0,12,2,35,1,22,1,1,42,91,1,15,2};
  //METHOD 1
  int* ptr = arr;
  for(int i = 0; i < sizeof(arr)/sizeof(int); i++){
    printf("%d ",*(ptr+i));
  }
  printf("\n");

  //METHOD 2
  ptr = arr;
  for(int i = 0; i < sizeof(arr)/sizeof(int); i++){
    printf("%d ",*ptr);
    ptr++;
  }
  printf("\n");


  //METHOD 3
  ptr = arr;
  for(int i = 0; i < sizeof(arr)/sizeof(int); i++){
    printf("%d ",*ptr++);
  }
  printf("\n");


  //METHOD 4
  ptr = arr;
  for(int i = 0; i < sizeof(arr)/sizeof(int); i++){
    printf("%d ",*(ptr++));
  }

위와 같이 4가지 방법을 생각할 수 있습니다. 첫 번째는 이미 다루었었고, 두 번째는 포인터의 연산을 이용한 것입니다. 그러나, 두 번째 방법을 ++을 이용하여 세 번째 방법으로 확장할 수 있습니다. 이 때 둘의 연산 순서가 같지만, 오른쪽이 우선되어 덧셈을 하고 포인터 값을 가져올 것같지만, 후위 연산자이기 때문에 현재 포인터가 가르키고 있는 값을 가르키고, 포인터에 1을 더하게 됩니다. (4번도 동일합니다.)

만약, 종료를 나타내는 값이 따로 있다면, 코드는 더 간결해질 수 있습니다.

int arr[] = {0,0,12,2,35,1,22,1,1,42,91,1,15,2,-1};
int* ptr = arr;
while(*ptr != -1) printf("%d ",*ptr++);

이 경우 -1을 종료를 나타내는 값으로 사용했고, 굳이 괄호를 쓸 필요없이 위와 같이 간단한 코드를 작성할 수 있습니다.

포인터 변수에는 정수를 직접 대입하는 것도 불가능합니다. 번지를 굳이 직접 언급할 일도 거의 없을 뿐더러 오류를 일으킬 가능성도 있기 때문입니다. Error: invalid conversion from 'int' to 'int*'과 같이 묵시적인 변환을 할 수 없다는 에러가 뜰 것입니다. 물론 캐스팅 연산자를 이용해 변환하여 대입할 수는 있습니다.

이 예외가 되는 값이 있는데 0입니다. 포인터에 0을 대입할 수도 있고, 0이랑 포인터를 비교할 수도 있습니다.

이는 0이란 주소가 특별한 의미를 가지고 있어서가 아니라, 일반적으로 접근할 수 없는 주소이기 때문입니다. 포인터를 반환해야 하는 함수라면 0을 반환할 수도 있습니다. 에러를 처리하기 위해(비교의 경우라면 이러한 함수에 대해서 에러가 있는지 판단하기 위해) 사용될 수 있습니다. 특정 주소를 찾는 경우 주소를 찾을 수 없을 때, 0을 반환하는 것을 고려해볼 수 있습니다.

다만, 0이 무슨 의미를 나타내는지 알아차리기 쉽지 않을 수 있어 NULL이라는 상수를 대신 이용합니다. (만약, 0번째 주소가 의미가 있어지더라도 NULL 상수 값만 바꾸면 오류를 막을 수 있기 때문도 있을 것입니다. )

int* whereIs12(int* arr_start) {
  int* p = arr_start;
    while(*p != -1) {
      if (*p == 12) return p;
      p++;
    }
    return NULL;
}

int main(){
  int arr[] = {0,0,2,2,35,1,22,1,1,42,91,1,15,2,-1};
  if (whereIs12(arr) == NULL) { printf("NO SUCH ELEMENT"); }
  else { printf("%d",*whereIs12(arr)); }
}

위 예시는 12의 위치를 찾는 함수입니다. 저렇게 복잡한 함수를 쓸 이유는 없겠지만, 아무튼 저런 식의 함수가 있을 때, 값을 찾지 못한 경우 NULL을 반환하게 해볼 수 있습니다.

물론, 종료를 나타내는 -1을 사용하지 않고, 아래와 같이 배열을 함수에 전달하는 경우도 가능할 것입니다.

int* whereIs12(int* m_arr) {
  int* p = m_arr;
  for(int i  = 0; i < sizeof(m_arr); i++) {
      if (*p == 12) return p;
      p++;
  }
  return NULL;
}

int main(){
  int arr[] = {0,0,2,12,35,1,22,1,1,42,91,1,15,2};
  if (whereIs12(arr) == NULL) { printf("NO SUCH ELEMENT"); }
  else { printf("%d",*whereIs12(arr)); }
}

한편, 포인터의 포인터나 void의 포인터와 같은 상황도 가능합니다. void포인터의 경우 char*처럼 1바이트 단위로 주소를 가져올 때 사용됩니다. (당연하지만, 명시적 형 변환이 없으면 *ptr로 값을 가져올 수 없습니다.) 이중 포인터의 경우 다른 글에서 다시 다루도록 하겠습니다.

[프로그래밍] 6.4 포인터와 배열 (1)

StudyingCobble — Sat, 15 Feb 2020 13:40:35 +0900

포인터는 C/C++에 존재하는 개념입니다. 포인터에 대한 설명을 Wikipedia에서 가져와 봤습니다.

밍 언어에 대한 기초적인 이해를 가정하고 있습니다. 최소 프로그래밍 언어 하나 정도를 약간이라도 접해보시는 것을 추천합니다. 또한, 이 글은 심화 내용은 되도록 피하여 서술했습니다.

포인터는 C/C++에 존재하는 개념입니다. 포인터에 대한 설명을 Wikipedia에서 가져와 봤습니다.

■ pointer is a programming language object that stores a memory address.

■ A memory pointer (or just pointer) is a primitive, the value of which is intended to be used as a memory

address; it is said that a pointer points to a memory address.

■ More generally, a pointer is a kind of reference, and it is said that a pointer references a datum stored

somewhere in memory; to obtain that datum is to dereference the pointer. The feature that separates

pointers from other kinds of reference is that a pointer's value is meant to be interpreted as a memory

address, which is a rather low-level concept.

(From https://en.wikipedia.org/wiki/Pointer_(computer_programming))

그리고 여기에 존재하는 reference의 개념은 다음과 같이 정의되어 있었습니다.

■ In computer science, a reference is a value that enables a program to indirectly access a particular datum.

(From https://en.wikipedia.org/wiki/Reference_(computer_science))

위의 내용을 요약해보자면, 포인터는 메모리 주소(memory address)를 저장하는 것으로서, 이를 통해 특정 데이터에 대한 간접적인 접근을 가능하게 한다고 볼 수 있겠습니다. 그리고 이는 넓은 의미에서 reference에 포함됩니다.

그런데, C++, Java에는 또다른 reference의 개념이 있습니다. 여기서 reference 개념은 보다 좁은 의미의 개념으로 볼 수 있습니다. 이러한 흐름을 요약해보자면 다음과 같이 그려볼 수 있겠습니다. (관련 내용은 이후 다른 글에서 다루어보겠습니다.)

하지만, 이러한 구현은 컴파일러나, 운영 환경, 언어와 버전마다 다를 수 있음을 알아두어야 합니다. 또한, 정의하기 나름이겠지만 Reference가 넓은 의미에서 저 두가지만을 포함하는 것은 아닙니다. 그리고 분류하기 나름이겠지만, C++의 Reference에는 없는 C++의 Pointer와 Java의 Reference의 공통점이 존재하기도 합니다.

서론이 길었지만, 결국 포인터는 (적어도 C/C++에서는) 메모리 주소를 저장하여, 특정 데이터에 간접적으로 접근할 수 있게 해주는 것이라 할 수 있습니다. 이러한 포인터 변수를 만든다고 생각하면, 일반적인 변수 선언과 함께, 이게 포인터라는 점, 그리고 어떤 데이터를 가리킬 것이라는 점을 알려줘야 할 것입니다.

특별히 그 데이터가 어떤 데이터인지 알려주면, 변수의 크기가 다양하기 때문에, 시작하는 곳의 메모리 주소부터 시작해서 정확히 원하는 지점까지 가져올 수 있을 것입니다.

예를 들어, int형 (4 Byte) 변수 bar를 간접적으로 가리키는 포인터 변수 foo를 선언해 볼 수 있을 것입니다. 이는 코드 상에서는 다음과 같이 나타납니다. (bar는 위에 어딘가 선언되었다고 가정해봅시다)

int *foo;
foo = &bar;

여기서 첫번째 줄의 *는 연산자가 아니라, 그냥 포인터임을 알려주는 용도일 뿐입니다. 일종의 구두점으로서, 우리가 말하면서 ?나 !을 사용하는 것과 비슷한 느낌입니다.

두번째 줄은 foo라는 int형 포인터에 bar의 주소를 대입하는 식입니다. 여기서 &는 주소 연산자로, 변수의 주소를 얻기 위해 사용됩니다.

참고로 다음과 같은 식도 가능합니다. 이 경우, foo는 정수형 변수, bar는 정수형 포인터 변수가 됩니다.

int foo, *bar;

즉 *의 위치와 사이 공백의 유무는 의미차이를 주지 않습니다. 만약 둘다 포인터로 만들고 싶다면, ' * '을 두 번 사용해야 할 것입니다.

포인터의 개념을 말하면서, 간접적으로 데이터에 접근한다는 점을 위에서 언급했었습니다. 다시 그 값에 접근하기 위해서는 *연산자를 사용합니다. 여기서는 일종의 단항(Unitary) 연산자라고 볼 수 있습니다.

int bar = 10;
int *foo;
foo = &bar;
printf("%d",*foo);

선언할 때의 *는 일종의 구두점으로 값을 참조할 때 사용하는 *는 연산자로서 다른 의미를 가집니다. 아래 구문은 따라서 가리키는 값에 주소값을 집어넣는 게 아니라, 포인터 변수를 초기화하는 예시가 됩니다. (애초에 가리키는 값에 주소값을 집어넣는 다는 이야기 자체가 성립하지 않습니다.)

int bar = 100;
int *foo = &bar;
// int *foo; foo = &bar; 와 동일

포인터가 값을 저장하지 않는다는 사실은 직접 그 값을 출력해 보면 확인할 수 있습니다. 또한 그 크기를 구해봐도 확인할 수 있습니다.

그리고 아래 예시로 부터, 참조하는 변수의 값이 변화하면 가리키는 값도 당연히 변화하는 것을 확인할 수 있습니다.

# include <iostream>

using namespace std;

int main(){
  int bar = 300;
  int *foo = &bar;
  __int64 big_bar = 300;
  __int64 *bfoo = &big_bar;
  cout << "*foo : " << *foo << ", sizeof(foo) : " << sizeof(foo) ;
  cout << ", sizeof(bfoo) : " << sizeof(bfoo) << endl;
  cout << "sizeof(*bfoo) : " << sizeof(*bfoo) << ", foo : " << foo << endl;
  bar = 500;
  cout << "*foo after the change in bar : " << *foo << endl;
}

-----------------RESULT-----------------
*foo : 300, sizeof(foo) : 4, sizeof(bfoo) : 4
sizeof(*bfoo) : 8, foo : 0x61ff04
*foo after the change in bar : 500

포인터 변수의 크기는 컴파일러나 운영환경, 그리고 CPU에 따라 달라집니다. 1 word만큼(CPU가 한 번에 처리하는 데이터 크기)을 사용하는 것이 일반적입니다. 이는 32비트 시스템에서는 32비트 = 4 바이트, 64비트 시스템에서는 64비트 = 8 바이트가 됩니다. 32비트 시스템은 32개 비트를 가지고 메모리의 주소를 표현하므로, 이렇게 설정하는 것이 합당해 보입니다.

(하지만, 운영체제에 따라 주소를 64비트로 표현하는 것이 아닌 더 작은 비트만으로 표현하기도 합니다. 이 경우 64비트에 해당하는 주소를 모두 차지할 만큼 메모리를 증설하는 것은 불가능합니다. 그리고 이러한 세부 사항은 컴파일러나 여러가지 조건에 좌우될 수 있습니다.)

다음 글에서는 본격적으로 포인터를 활용하고 연산하는 과정에 대해 알아보겠습니다.

[프로그래밍] 6.3 register, volatile & 메모리의 구조

StudyingCobble — Thu, 13 Feb 2020 19:57:03 +0900

(제목의 기억 부류 지정자는 Storage Class Specifier를 번역한 것입니다. 기억 영역 클래스 지정자, 기억 클래스 지정자 등 다양한 번역이 존재하지만, 클래스라고 번역하는 것은 class 키워드로 지정되는 그 클래스와 혼동될 우려가 있어 위의 용어로 사용하였습니다. Microsoft Docs에서는 스토리지 클래스 지정자로 표기하고 있습니다.)

이번 글에서는 register, volatile 지정자와 메모리에 관한 내용을 다룹니다. 사실 volatile 지정자는 C언어의 기억 부류 지정자로 분류되지 않지만, 메모리에 관한 이야기를 하기 위해 같이 다룰 예정입니다.

register 지정자는 C/C++에만 존재하며, volatile 지정자는 C/C++, Java에 존재하는 지정자입니다. register 지정자는 CPU의 레지스터에 변수가 우선적으로 할당될 수 있도록 하며 volatile 지정자는 CPU 레지스터가 아닌 메모리에서만 변수가 저장되도록 설정합니다. 좀 더 자세히 말하자면, register 지정자는 변수에 대한 접근 속도가 최대한 빠르도록 하는 지정자이고, volatile 지정자는 그러한 최적화를 방지하는 지정자입니다. (이러한 구현은 컴파일러나 언어마다 약간씩 차이가 있을 수 있습니다.)

사용법은 다음과 같이 간단합니다.

register int regVar;
volatile int volVar;

이러한 지정자가 있는 변수들의 동작 과정을 이해하기 위해서는 컴퓨터 메모리에 대한 약간의 이해가 필요합니다. (이번 글에서는 간단하게만 다루어 보겠습니다.)

컴퓨터는 동작하기 위해 저장소와 처리 장치가 필요합니다. 저장소에는 HDD와 SSD같은 보조 기억 장치, RAM과 같은 주 기억 장치가 포함됩니다. 특히 주 기억 장치는 컴퓨터를 끄는 순간 데이터가 날아가기에 휘발성 메모리(Volatile Memory)에 속합니다.

그러나 이러한 저장소 외에도 CPU에서 처리중인 데이터를 저장하기 위해 사용되는 프로세서 레지스터(Processor Register)와 레지스터는 아니지만, 빠른 접근을 위해 CPU에 포함되어 있는 저장 공간인 캐시(Cache)가 있습니다. 이러한 저장소는 다음과 같은 식의 계층 구조(Hierarchy)를 이룹니다.

(https://brunch.co.kr/@toughrogrammer/14를 참고하여 제작됨)

빠를 수록 작아지고, 느릴 수록 커지는 형태를 나타냅니다. 특별히 프로그램 실행 중에 주로 사용되는 공간은 레지스터부터 L1~L3(L4까지 있는 경우도 있습니다.) 캐시, 메모리 부분입니다. 일반적으로 메모리에 해당 내용이 저장되지만, 빠른 접근이 필요한 경우 캐시나 레지스터에 저장이 되고, 연산 과정 중이라면 레지스터로 그 값이 옮겨지게 됩니다.

그러나, 컴파일러는 이러한 방식이외에도 다양한 방식으로 메모리를 최적화합니다. 다음과 같은 코드가 대표적인 예시입니다. (물론, 그 방식은 컴파일러마다 약간씩 차이가 있을 수 있습니다.)

int var = 0;
for(int i=1;i<=10;i++){
	var +=1;
}

위의 코드는 var라는 변수에 10번이나 1을 더하는 코드입니다. 단순히 10을 더하기 위해 이렇게 썼다면, 매우 비효율적인 코드라고 할 수 있습니다. 그러나 이런 코드를 컴파일러는 다음과 같은 코드로 바꾸어 최적화 해볼 수 있습니다.

int var = 0;
var = 10;

volatile 지정자는 이러한 과정에서 최적화를 방지합니다. 지금까지 봤던 간단한 코드들에서는 의미가 없겠지만, 만약 변수값을 다른 프로그램이 변경할 수 있다면 이야기가 달라집니다. 만약, 다른 프로그램이 특정 변수 bar의 값을 변경할 수 있다고 생각해봅시다. 이 때 이 값이 1로 변경되면 루프를 끝내는 프로그램을 만든다고 생각해봅시다. 그러면 volatile을 배우기 전에 다음의 코드를 생각하게 될 것입니다.

static int bar;

//뭔가 그럴듯한 코드

bar = 0;
while (bar != 1)
  //뭔가 그럴듯한 코드

//뭔가 그럴듯한 코드

하지만, 이 코드는 다음과 같이 최적화될 수 있습니다.

//뭔가 그럴듯한 코드

while (true)
  //뭔가 그럴듯한 코드

//뭔가 그럴듯한 코드

이 경우, 그냥 무한 루프가 됩니다. 이를 방지하기 위해 volatile 지정자를 붙여줍니다.

static volatile int bar;

//뭔가 그럴듯한 코드

bar = 0;
while (bar != 1)
  //뭔가 그럴듯한 코드

//뭔가 그럴듯한 코드

또한 volatile 변수는 캐시 메모리 같은 곳에 변수를 저장하지 않게 하여, 변수를 참조할 때, 메모리에 저장된 그 값에 직접 접근할 수 있도록 한다는 특징도 있습니다. 이러한 특징은 하드웨어를 제어하거나, MMIO(Memory-mapped I/O : 입출력과 메모리가 하나의 메모리 공간에서 관리되는 것) 등을 위해서 사용됩니다.

하지만, 이는 멀티 스레드 프로그램을 구현할 때의 경우 문제가 발생할 수 있습니다. (C/C++) 이는 여러 연산들의 순서를 강제하도록 하는 메모리 배리어(Memory Barrier)를 확실히 보장하지 못합니다. 반대로 Java (Java 5 이후 버전)의 volatile은 이러한 기능을 보장한다는 점에서 C/C++과 다릅니다. (이에 관련된 내용은 링크1(Wikipedia), 링크2(StackOverflow)를 참고하시면 좋을 것 같습니다. 이는 C++11이후 Atomic Variables를 이용하여 보장될 수 있습니다.

지금까지 큰 틀에서 메모리를 살펴보았다면, 더 좁은 의미의 메모리(주 기억 장치)에 대해 살펴보겠습니다. 메모리는 운영체제에 의해 관리되어 프로그램에 할당됩니다. 메모리는 1차원의 공간으로 구성되며, 각 공간의 주소는 일반적으로 16진수로 표기합니다. 이는 일반적으로 메모리와 관련된 단위들이 2의 거듭제곱 진법 형태를 가지기 때문입니다. 16진수는 다른 2,8 진법 등으로 쉽게 변환할 수 있습니다. 아래는 그 예시를 보여줍니다.

실제로 메모리를 사용할 때는 물리적인 주소가 아닌, 가상적인 주소를 가지고 사용하게 됩니다. 특히 이 과정에서 보조 기억 장치의 메모리를 가져와 더 큰 메모리를 제공하게 할 수도 있습니다. 이러한 기술을 '가상 메모리'라고 합니다. 아래 그림은 이를 간략하게 보여줍니다.

Virtual Memory(per process)

이러한 메모리는 다음과 같은 구조로 관리가 됩니다. 아래 그림은 C/C++에서 프로그램에 할당되는 메모리가 관리되는 모습을 시각화한 것입니다.

코드 부분에는 말 그대로 코드가 저장됩니다. 그냥 코드는 아니고 기계어로 변환된 코드와 문자열과 같은 상수값들이 저장됩니다. (문자열과 같이 read-only인 상수 값들은 text영역에 저장됩니다.)

데이터 부분에는 프로그램 실행 내내 저장되는 변수들, 즉 전역 변수와 정적 변수가 저장됩니다. 초기화 되지 않은 값은 BSS(Block State Symbol) 영역에 저장됩니다. 이는 변수가 있을 공간만 확보해두고, 실제로 그 값을 저장하지는 않습니다. (이는 런타임 도중에 확보됩니다.) 코드와 데이터 부분은 컴파일 도중에 확보되는 영역입니다. 반대로, 힙과 스택은 실행 도중에 확보되는 영역입니다.

Stack의 작동 원리

힙은 동적으로 할당되는 영역입니다. 이에 대해서는 나중에 다룰 예정입니다. 프로그램 실행 도중 그 크기가 변경되어야 할 때 직접 사용자가 할당하는 영역으로 위에서 아래로 채워집니다. (그림 상에서의 위치를 이야기 한 것입니다.)

스택은 아래서 위로 채워지며, 지역변수와 매개변수 등 함수와 관련된 변수들이라고 보면 됩니다. 함수가 소멸될 때 해당 변수들은 메모리상에서 소멸됩니다. (스택 용량이 초과되는 경우, 이를 Stack Overflow라고 합니다. 이 경우 오류가 발생합니다.)

이름이 나타내듯이 후입선출 (Last In First Out : LIFO) 방식으로 작동해 나중에 저장된 (스택에서 이러한 동작을 push라고 합니다.) 값이 가장 먼저 인출되게 됩니다. (이러한 동작은 pop이라고 합니다.) 접시가 쌓여있는 모습을 생각하시면 좋을 것 같습니다. 가장 위에 놓인 접시는 가장 늦게 놓여진 접시이자 가장 먼저 사용되는 접시입니다.

스택은 그냥 데이터를 쌓고 지우므로 빠르지만, 힙은 빈 공간이 있는지 확인하고 저장하기 때문에 속도가 느립니다. 대신 힙은 언제든지 데이터를 삭제하고 추가할 수 있습니다. 스택 영역이 stack 방식으로 데이터를 쌓는 이유를 이해하려면, 스택 프레임(Stack Frame)에 대해서 알아야 합니다. 이는 스택에 차곡차곡 저장되는 함수의 호출 정보를 나타냅니다. 아래는 스택 프레임의 작동 방식을 보여줍니다.

프로그래밍 언어마다 이러한 형태는 차이가 있습니다. 예를 들어 Python에는 전역 변수가 없으므로, 전역 변수가 저장되는 공간은 없을 것입니다. 특별히 Python은 Python Memory Manager, Java는 Java Virtual Machine에서 메모리를 관리하므로, 사용자가 동적 할당(Dynamic Memory Allocation)을 할 일은 거의 없습니다. 그러나 각 언어마다 용어가 달라서 하나로 통일하기는 힘들지만, '스택'과 '힙'은 대부분의 상황에서 사용되는 개념인 것 같습니다. (static 영역이 heap영역에 합쳐지는 등의 경우는 있지만, 대체로 stack과 heap의 개념은 찾아볼 수 있었습니다.)

특별히 Java의 경우 int와 같은 Primitive Data Type들의 경우만 stack에 저장되고, 나머지 Reference Variables는 heap에 저장되게 됩니다. Python의 경우도 비슷하게 heap 공간을 사용하고, 이 공간은 가상 머신이 관리하게 됩니다.

이러한 경우 스택에는 함수의 호출 정보(C/C++의 경우와 같이)와, 참조 변수들의 주소 등이 저장됩니다.

메모리가 동적으로 관리되는 Python과 Java는 Garbage Collection(직역하면 쓰레기 수집입니다.)이라는 과정을 통해 사용되지 않는 메모리를 해제합니다. 이는 스택과 힙의 개념을 통해서 함께 이해할 수 있습니다. 실제 과정은 더 복잡하지만 단순화하자면, heap에 저장된 값이 unreachable, 즉 도달할 수 없으면 제거합니다.

왼쪽은 str1이라는 String 변수가 Heap의 한 값을 참조하는 것을 보여줍니다. 그러나 str1의 값이 변경되면, 기존에 존재하던 문자열을 두고 새로운 값이 Heap에 할당되어 연결됩니다. 그러면 기존에 있던 문자열은 도달할 수 없게 되고, Garbage Collector가 실행되면서 이 값을 만나게 되면, 메모리에서 제거되는 것입니다.

이렇게 해서 메모리에 관한 기초적인 내용까지 다루어 보았습니다.

[프로그래밍] 6.2 기억 부류 지정자 (2)

StudyingCobble — Sat, 25 Jan 2020 18:12:38 +0900

※이 글은 프로그래밍 언어에 대한 기초적인 이해를 가정하고 있습니다. 최소 프로그래밍 언어 하나 정도를 약간이라도 접해보시는 것을 추천합니다. 또한, 이 글은 심화 내용은 되도록 피하여 서술했습니다.

정적(static) 변수는 말 그대로 정적인 공간에 기억되는 변수입니다. 일반적인 지역 변수와는 다르게 프로그램 실행 내내 그 값이 유지될 수 있는 장점이 있습니다. 전역 변수와 비슷해보이지만, 전역변수와는 다르게 정적 변수는 지역 변수와 같이 통용되는 범위가 제한됩니다. 선언되는 지역도 지역변수와 동일합니다. 두 기억 부류의 특징을 둘 다 가졌기에, 둘의 장점을 결합하여 다음과 같은 예시를 가능하게 합니다.

# include <iostream>

using namespace std;

void counter();

int main(){
  for(int i = 0 ; i < 10 ; i++){
    counter();
  }
}

void counter(){
  static int cnt = 0;
  cnt++;
  cout << "Number : " << cnt << endl;
}

---------------RESULT------------------
Number : 1
Number : 2
Number : 3
Number : 4
Number : 5
Number : 6
Number : 7
Number : 8
Number : 9
Number : 10

static을 빼고 int cnt = 0;이라고 했다면, 다음의 결과가 나옵니다.

Number : 1
Number : 1
Number : 1
Number : 1
Number : 1
Number : 1
Number : 1
Number : 1
Number : 1
Number : 1

계속 기억 공간에 저장되어 있기 때문에 가능한 일입니다. 위의 예시에서 보았듯이 static변수는 C/C++, Java에서 static int cnt;와 같이 static 키워드를 붙임으로서 선언 가능합니다. (int static cnt;도 가능합니다.)

Java에서 위의 코드를 그대로 가져올려고 하면, 일단 C/C++처럼 함수가 독립적으로 존재하지 못하므로 내용을 각색해야할 필요가 있습니다. 아래 코드는 나름대로 위와 비슷하게 각색해본 결과입니다.

public class HelloWorld {
    static int cnt = 0;
    public static void main(String[] args) {
      for(int i = 0 ; i <10 ; i++){
        counter();
      }
    }
    private static void counter(){
      cnt++;
      System.out.println(cnt);
    }
}
------------------RESULT----------------------
1
2
3
4
5
6
7
8
9
10

큰 차이점이 있다면, 메소드 내부에서 static 변수를 선언할 수 없어서 클래스 내부 선두에 따로 선언해주고, counter 메소드 선언할 때 정적 공간에 선언하기 위해 static 키워드를 붙였습니다.( 관련 내용은 이전에 다루었기에 생략하겠습니다. )

특별히 한 가지를 더 언급해보자면, Java에는 C/C++과 정확히 같은 개념의 전역 변수가 없지만, 정적 변수가 비슷한 느낌을 가지고 있기에, Java의 정적 변수를 전역 변수로 설명한 글들이 인터넷 상에 많이 있었습니다. 이 글에서는 확실히 그 둘을 분리하여 설명하겠습니다.

Python은 아예 static 키워드가 없습니다. 그러나 비슷한 느낌을 내는 것은 가능합니다. 먼저 전역 변수를 사용하는 방법도 있겠지만, 전역 변수의 단점이 많기에, 위의 C++코드와 비슷한 느낌을 내려면 다음과 같이 써볼 수 있습니다.

def counter():
    counter.cnt += 1
    print(counter.cnt)
counter.cnt = 0
for i in range(0,10):
    counter()

약간 뜬금없이 counter를 객체처럼 사용하는 걸 보실 수 있습니다. 이는 함수가 python(을 비롯한 C 등을 제외한 모든 언어에서) 객체이기 때문입니다. 특별히 Python은 특별한 선언이 따로 필요하지 않고, 대입식을 선언문으로 활용할 수 있기에 위와 같은 깔끔한 식이 가능해집니다. (당연하겠지만, 함수를 인수로 받거나, 함수를 반환하는 함수도 가능합니다.)

참고로 C/C++에서 정적 함수를 선언하면(static method가 아니라 static function) 일반적인 함수와 (전역으로 생성되는) 비슷하지만, 외부에 알려지지 않습니다. (extern의 반대 개념 정도로 사용된다고 보면 됩니다.) 즉, 외부 모듈에서 참조할 수 없습니다.

typedef 키워드는 C/C++에 존재하는 기억 부류 지정자입니다. 하지만, 사실 기억 부류를 지정하는 것과는 거리가 있습니다. 그냥 C/C++의 기억 부류 지정자가 오는 자리에 오는 특별한 친구정도로 기억하시면 될 것 같습니다. 정확한 의미는 기억부류 지정자의 위치에 사용되어, 기존에 존재하는 자료형에 새로운 이름을 만들어줍니다. 아래 예시를 참고해봅시다.

  typedef short FILE_SIZE;
  FILE_SIZE f1_size = 10;

(통용 범위는 일반적인 변수와 같이 블록 내로 제한됩니다.(블록 내에서 선언되었다면))

(나중에 해당 이름을 다른 용도로 사용한다면 반드시 자료형을 제공해서 const flag가 아닌 const int flag와 같이 사용해야 합니다.(flag가 typedef를 통해 다른 자료형의 또다른 이름으로 사용된 상황에서) const int;와 같은 식이 불가능한 이유와 같습니다.)

굳이 이를 사용하는 이유는 여러가지가 있겠지만, 구조체나 클래스 형식으로 변수를 생성할 때 가독성을 늘리기 위함도 있고, 위와 같이 특정 용도로 사용하는 변수의 자료형이 바뀔 필요가 있다면, 한번의 변경으로 바꾸기 위함도 있습니다.

또한, 다음과 같은 예시도 가능합니다.

typedef int tfi( short ), (*ptfi)( short ); 
// short를 인수로 받고 int형을 반환하는 함수형 tfi
// short를 인수로 받고 int*형을 반환하는 함수형 포인터 ptfi

int ( *signal( short, int (*) (short)) ) ( short );
//signal은 포인터로서, 'short를 받고 int를 반환하는 함수(#1)'를 반환하는 함수(#2)를 가르킴.
//그리고 그 함수 #2는 [short형]과 ['short를 받고 int를 반환하는 함수(#3)'의 포인터(#4)]를 받음.
tfi *signal( int, tfi * ); // 위와 같은 의미
ptfi signal( int, ptfi ); // 위와 같은 의미

(https://docs.microsoft.com/ko-kr/cpp/c-language/typedef-declarations?view=vs-2019의 예시를 각색했습니다)

(포인터와 배열 형식도 위와 같이 typedef로 선언할 수 있습니다.) 위 코드의 자세한 의미는 포인터에 관한 글(추후 추가 예정입니다)를 보고 오면 이해가 될 겁니다. 그렇지만, typedef를 통해 코드의 가독성이 높아짐을 확인할 수 있습니다.

[프로그래밍] 6.1 기억 부류 지정자 (1)

StudyingCobble — Mon, 20 Jan 2020 14:07:33 +0900

이번 글의 범위는 다음과 같습니다.

	C/C++	Java	Python
기억 부류 지정자
전역	extern	(별도의 개념 존재X)	global
지역	auto	해당 개념 존재
정적	static	static
레지스터*	register
typedef	typedef
형 한정자(type qualifier) (여러 종류가 있지만, 이 글에서는 volatile만 다루었습니다. register의 개념과 대조하기 위해 같이 설명할 예정입니다.)
volatile	volatile	volatile
* register 변수라고 해서 무조건 레지스터에 저장되는 것이 아닙니다. 일단 그 공간도 적기도 하며, 공간이 없다고 에러가 나지도 않습니다. 좀 더 빨리 접근할 수 있도록 우선 순위를 준다고 보면 편합니다.

변수나 함수 등이 사용되려면, 일단 어딘가에는 저장이 되어야 합니다. 이는 CPU 내부의 공간일수도 있고(레지스터), 우리가 주기억장치로 사용하는 RAM일수도 있습니다. HDD나 SSD같은 보조 기억 장치에 저장하는 건 파일 입출력이며, 프로그램 실행중에 사용할 변수가 이런 곳에 저장되지는 않을 겁니다.

또한, 변수가 저장되더라도, 프로그램이 실행되는 내내 저장해둘 수도 있고, 사용되는 순간에만 저장하고 삭제할 수도 있습니다. 이러한 차이는 위에 서술한 많은 종류의 기억 부류 지정자를 필요하게 합니다.

하지만, 프로그래밍 언어의 차이는 이 중 일부를 쓸모가 없게 만들기도 합니다. 예를 들면, 레지스터 변수의 경우, Java와 Python에서는 존재하지 않습니다. 이는 두 언어의 경우 여러 운영체제에서의 호환성을 높이기 위해 별도의 메모리 관리 스템이 메모리를 관리하기 때문입니다. 따라서, 적절히 알아서 메모리를 할당하게 됩니다.

먼저 이 글에서는 전역 변수와 지역 변수에 대해 다루고, 다음 글에서는 정적(static) 변수와 typedef에 대해 다뤄보겠습니다.

(다다음 글에서는 register, volatile와 그 외 메모리에 관한 점들을 다룰 예정입니다.)

전역 변수와 지역 변수의 차이점은 적용 가능한 지역입니다. 전역 변수는 어디서든지 접근이 가능하고, 지역 변수는 특정 구역 내에서만 접근이 가능합니다.

이렇게만 보면 전역 변수가 좋은 것처럼 보이지만, 전역 변수는 프로그램 실행 내내 존재하기 때문에, 최적화 면에서 좋지 않을 수 있습니다. 또한, 지역 변수는 적용 범위만 다르면 이름이 같아도 상관없지만, 전역 변수는 그렇지 않아서 생기는 관리나 코딩 상 어려움도 존재합니다.(다른 코드를 가져다 쓰는 상황이라면, 수 백개에 달하는 전역 변수를 일일이 이름을 바꾸는 상황이 생길 수 있습니다.) 그 외 여러가지 단점이 있기에, Java에서는 직접적으로 전역 변수를 지원하지는 않습니다.

또 다른 차이점은 선언되는 지점입니다. 아래 코드는 C/C++과 Python에서 전역 변수 gloVal과 지역 변수 locVal이 정의되는 모습을 보여줍니다.

int gloVal;

int main(){
return 0;
}

void func01(){
  int locVal = 0;
}

gloVal = 0

def func01:
    locVal = 0

각 예시에서 볼 수 있듯이 어느 함수 안에 속하지 않은 지점에서 선언되면 전역 변수이고, 그렇지 않으면 지역 변수입니다. 특히 C/C++에서는 전역변수는 선언과 동시에 0으로 초기화됩니다. 이는 전역 변수의 경우, 지역 변수와 달리 초기화를 하지 않으면 큰일이 날 수 있는 상황에 많이 사용되기 때문으로 보입니다.

각 변수는 통용되는 범위에도 차이가 있습니다. 다음의 예시를 참고해봅시다.

# include <iostream>

using namespace std;

int gloVal;

int main(){
  cout << gloVal << endl;
  {
    int locVal;
    cout << locVal << endl;
  } // 지역 변수는 { }로 둘러싸인 블럭 내에서만 통용됩니다.
  return 0;
}

-------------------RESULT--------------------
0
4200955

gloVal = 0
def func0():
    locVal = 0
    print(gloVal)
    print(locVal)
func0()

-------------------RESULT--------------------
0
0

전역 변수는 어디서나 쓸 수 있지만, 지역 변수는 해당하는 함수나 블록에서만 통용됩니다. 따라서 다음의 코드는 에러를 발생시킵니다.

#include <iostream>

using namespace std;

int main(){
  {
    int i = 0;
  }
  cout << i << endl;
  return 0;
}
-----------------ERROR--------------
ERROR : 'i' was not declared in this scope
cout << i << endl;
^

전역 변수와 지역 변수와 관련된 지정자로 C/C++에선 extern과 auto, Python에서는 global이 있었습니다. 이 중, auto는 거의 쓰이지 않습니다. auto를 안 붙여도 함수 내에서는 지역 변수가 기본이고, 함수 밖에서 auto를 붙이면 에러가 발생하기 때문입니다. 즉 위의 예시에서 auto int i;와 같이 지정할 수 있지만, 그럴 필요가 없습니다.

extern(C/C++)과 global(Python)의 용법은 조금 더 복잡합니다. 지역 변수를 전역 변수로 만드는 개념이 아니라, 안에서 밖에 전역 변수가 있다고 알려주기 위해 쓰이기 때문입니다. 그리고 C++과 Python에서 사용하는 이 두 키워드에도 차이가 있습니다.

일단 Python의 global문입니다. 이를 이해하기 위해서 전역 변수에 관한 다음의 예시를 참고해봅시다.

var01 = 10
def func01():
    var01 = 1
    print(var01)
func01()
print(var01)
---------------RESULT--------------------------
1
10

분명 var01을 수정한 것 같은데, 전혀 값이 바뀌지 않았습니다. 이 경우 var01이라는 전역 변수와 func01에서만 통용되는 전역 변수 var01이 따로 존재하게 됩니다. (C++에서는 블록 내부에서 외부의 전역 변수를 수정할 수 있습니다.) 따라서 함수 내부에서는 전역 변수 var01이 가려지게 됩니다.

이런 경우 global을 통해 우리가 함수 내에서 사용한 var01이 사실은 전역변수라는 사실을 알려줄 수 있습니다.

var01 = 10
def func01():
    global var01
    var01 = 1
    print(var01)
func01()
print(var01)
------------------RESULT------------------
1

전역 변수의 값이 변경됨을 확인하였습니다. 하지만, 함수 내부에서 전역 변수 값을 수정하는 것보다 지역 변수를 사용하는게( 혹은 class의 멤버 변수를 통해 관리하는 게 ) 코드는 조금 늘어나도, 나중에 효율적으로 관리하는 데 도움이 된다고 합니다.

C/C++의 extern 지정자도 비슷하게 선언된 변수가 전역 변수라는 점을 알려줍니다. 그 전에 다음의 예시를 확인해봅시다.

# include <iostream>

using namespace std;

int main(){
  cout << gloVal <<endl;
  return 0;
}

int gloVal = 0;
--------------ERROR-----------------
ERROR: 'gloBal' was not declared in this scope
cout << gloBal <<endl;
^

이처럼 뒤에 선언된 전역 변수를 사용하기 위해서, extern 지정자가 필요합니다. 위 코드는 다음과 같이 대체될 수 있습니다.

# include <iostream>

using namespace std;

int main(){
  extern int gloBal;
  cout << gloBal <<endl;
  return 0;
}

int gloBal = 0;

이런 경우는 많이 없습니다. main함수 위쪽 모든 함수들 위에 전역 변수를 선언하는 것이 일반적이기 때문입니다. 그러나, extern이 필요한 경우가 하나 더 있는데, 외부 모듈에 있는 변수를 사용하기 위해 쓰입니다. 즉, 아직 정보가 없는 상황에서 그 전역 변수에 접근하는 데 사용됩니다. 이는 # include를 통해 가져온 외부 파일에 적용되며, 이에 관한 설명은 나중에 다시 다뤄보겠습니다.

C++에서는 지역 변수와 이름이 같아 가려진 전역 변수에 접근할 수 있는 방법을 다음과 같이 제공합니다.

# include <iostream>

using namespace std;

int varr = 0;

int main(){
  int varr = 10;
  cout << varr  << ',' << ::varr <<endl;
  return 0;
}
-------------------RESULT---------------
10,0

간단하게 ::변수이름 과 같이 쓰면 됩니다.

[프로그래밍] 5.5 클래스(5) - 클래스의 상속 (2)

StudyingCobble — Thu, 9 Jan 2020 20:29:50 +0900

※이 글은 프로그래밍 언어에 대한 기초적인 이해를 가정하고 있습니다. 최소 프로그래밍 언어 하나 정도를 약간이라도 접해보시는 것을 추천합니다. 또한, 이 글은 심화 내용은 되도록 피하여 서술했습니다.

오버라이딩과 오버로딩은 비슷하게 생겼지만, 서로 다른 의미를 나타내고 있습니다. 특히 메소드 오버라이딩과 함수 오버로딩은 얼핏 보면 같은 것으로 착각하기 쉽지만 아래와 같은 차이를 지닙니다.

	메소드 오버라이딩	함수 오버로딩
영어	Method Overriding	Function Overloading
의미	부모 클래스에서 구현된 메소드를 자식 클래스에서 재정의하는 것(재정의)	함수 이름은 같으나 매개 변수 등의 특징이 다른 여러 함수를 만드는 것(중복 정의)

이번 글에서는 상속에 관해 좀 더 알아보는 것과 함께 생성자 오버라이딩과 메소드 오버라이딩에 대해서 좀 더 알아보겠습니다.

먼저 상속할 클래스의 액세스 지정입니다. 클래스를 쓰고 활용하는 이유 중 하나는 내부의 정보를 숨길 수 있다는 점입니다. 이러한 점은 클래스 상속에서도 유지되어, 자식 클래스가 접근할 수 있는 정보를 제한할 수 있습니다. 이러한 내용은 사실 https://stdcobble.tistory.com/167에서 다룬 바 있지만, C++의 경우 상속하면서도 이러한 액세스 지정이 필요합니다.

class Child : public Parents{ 
public:
 int num1;
}

이는 다음과 같이 정리해볼 수 있습니다.

복잡하게 정리해놓았지만, 단순히 이야기하면 상한선을 만들어 놓은다고 보면 됩니다.

이러한 상속 액세스 지정이 없다면 클래스는 자동적으로 private으로 상속 액세스를 지정합니다. (나중에 언급할 구조체의 경우 public이 기본값입니다.)

메소드 오버라이딩은 이미 부모 클래스에서 정의된 메소드를 자식 클래스에서 재정의하는 것을 말합니다. 이는 아예 기능을 갈아 엎기 위함일 수도 있고, 아니면 기능을 확장하기 위함일수도 있습니다. 여기서는 기능을 확장하는 예시로서 살펴보겠습니다.

# include <iostream>

using namespace std;

class Parents{
public:
  void exampleMethod(int num1){
    cout << num1 << endl;
  }
};

class Child : public Parents{
public:
  void exampleMethod(int num1, int num2){
    Parents::exampleMethod(num1+num2);
    cout << num1 << num2 << endl;
  }
};

int main(){
  Child ch;
  ch.exampleMethod(10,20);
}

-----------------실행 결과-------------
30
1020

여기서 :: 연산자가 사용되어 부모 클래스의 메소드에 접근했습니다. :: 연산자는 . 연산자처럼(ch.exampleMethod()에서) 멤버가 속한 클래스를 지정합니다. 차이점은 . 연산자는 C++의 경우 객체에만, ::은 C++에서 클래스에만 사용된다는 점입니다. Python이나 Java에서는 . 연산자가 존재하지 않습니다.

이와 같은 방식으로 Java와 Python코드를 짤 것으로 기대할 수 있습니다. 하지만 다음 코드는 오류를 냅니다.

class Parents {
  public void methodExample(int num1){
    System.out.println(num1);
  }

}

class Child extends Parents {
  public void methodExample(int num1, int num2){
    Parents.methodExample(num1+num2);
    System.out.println(num1+","+num2);
  }
}

--------------
ERROR!

이는 Parents.methodExample()의 의미가 C++에서 Parents::methodExample()과는 다르기 때문입니다. C++에서는 non-static한 method도 위 식으로 접근가능했지만, Java는 이를 허용하지 않습니다. 이는 super라는 키워드로 대체됩니다.

public class HelloWorld {
    public static void main(String[] args) {
      Child ch = new Child();
      ch.methodExample(10,20);
    }
}

class Parents {
  public void methodExample(int num1){
    System.out.println(num1);
  }

}

class Child extends Parents {
  public void methodExample(int num1, int num2){
    super.methodExample(num1+num2);
    System.out.println(num1+","+num2);
  }
}

------------------------RESULT----------
30
10,20

100% 그런다고 장담은 못하지만, Parents가 들어갈 자리에 super를 넣는다고 생각하시면 됩니다. 생성자라면 그냥 super만 써야 겠죠.(생성자 오버라이딩의 경우 저번 글에서 가볍게 다루었습니다.) 다만, super를 두번 써서 super.super()와 같이 쓰는 것은 불가능합니다.

Python도 비슷합니다. 그러나 약간의 차이점이 존재합니다.

class parents:
    def someNiceFuction(self,num1):
        print(num1)

class child(parents):
    def someNiceFuction(self,num1,num2):
        super.someNiceFuction(num1*num2)
        print(num1+num2)

ch = child()
ch.someNiceFuction(7,3)

---------------------
ERROR!

위 코드는 에러를 냅니다.

아래 코드는 에러가 안 납니다.

class Parents:
    def someNiceFuction(self,num1):
        print(num1)

class Child(Parents,Aparents):
    def someNiceFuction(self,num1,num2):
        super().someNiceFuction(num1*num2)
        print(num1+num2)

ch = Child()
ch.someNiceFuction(7,3)

괄호 하나의 차이인것 같지만, Python에서는 괄호가 꼭 필요합니다. 이는 다중상속이 지원되는 Python에서는 super가 단순히 부모 클래스를 의미하는 것으로만 쓰이지 않을 수 있기 때문입니다. 아래의 코드는 족보가 꼬인 예시입니다.('족보'라는 표현을 쓰지는 않지만, 부모-자식 관계여서 족보라고 표현해봤습니다.)

이러한 관계에서 Child의 부모 클래스가 뭐라고 말하긴 애매합니다. 이때 super는 정해진 순서에 따라 가장 가까운 부모나 친척 클래스를 탐방하게 됩니다. 위 상황은 코드로 옮겨봤습니다.

class Gparents:
    def someNiceFuction(self,num1):
        print("Giant Penguin says "+str(num1))

class Parents(Gparents):
    def someNiceFuction(self,num1):
        print("Parents say "+str(num1))

class Aparents(Gparents):
    def someNiceFuction(self,num1):
        print("Aparents say "+str(num1))

class Child(Parents, Aparents):
    def someNiceFuction(self,num1,num2):
        super().someNiceFuction(num1*num2)
        print("Child1 says "+str(num1+num2))
        
ch = Child()
ch.someNiceFuction(7,3)

여기서 실행결과는 다음과 같습니다.

Parents say 21
Child says 10

어떤 우선순위에 따라서 Parents 클래스가 우선되었습니다. (제 경우 그랬습니다.) 하지만, super의 사용은 좀 더 복잡합니다. super는 다음과 같이 사용됩니다.

super(type[, object or type])

만약 인수들이 모두 생략되면, 우리가 알다시피 자녀 클래스에서 부모 클래스를 찾게 됩니다. 그러나, 이를 직접 지정할 수도 있습니다. 먼저, 다음과 같이 외부에서 사용하는 것도 가능합니다.

ch = Child()
super(Parents,ch).someNiceFuction(76)
super(Aparents,ch).someNiceFuction(77)
----------------RESULT-----------
Aparents says 76
Giant Penguin says 77

(이어지는 상황이라고 해봅시다)

위의 결과에서 ch 객체를 기준으로 탐색을 하는데, 두번째 줄은 Parents라는 클래스형을 기준으로 탐색해서 super class를 탐색합니다. 그 결과 Gparents가 아닌 Aparents가 선택되었습니다. 그 다음 줄은 Aparents의 부모 클래스인 Gparents가 선택되었습니다. 이 선택의 기준에 대해서는 나중에 다시 이야기 해보겠습니다.

아직 결과가 이해가 되진 않을 수 있지만, 적어도 다음 코드의 결과를 예상해볼 수 있게 되었습니다.

class Parents(Gparents):
    def someNiceFuction(self,num1):
        print("Parents say "+str(num1))

class Aparents(Gparents):
    def someNiceFuction(self,num1):
        print("Aparents say "+str(num1))

class Child(Parents, Aparents):
    def someNiceFuction(self,num1,num2):
        super().someNiceFuction(num1*num2)
        super(Child,self).someNiceFuction(num1*num2)
        super(Parents,self).someNiceFuction(num1*num2)
        Aparents().someNiceFuction(num1*num2)
        super(Aparents,self).someNiceFuction(num1*num2)
        print("Child says "+str(num1+num2))


ch = Child()
ch.someNiceFuction(7,3)

어떤 걸 기준으로 할 때 뭐가 먼저일지는 모르지만, 위의 결과로 보건데 다음의 결과가 나타날 것이라는 걸 예측할 수 있을 겁니다.

Parents say 21
Parents say 21
Aparents say 21
Aparents say 21
Giant Penguin says 21
Child says 10

이러한 탐색 순서는 Method Resolution Order, MRO라고 하며, 다음의 메소드로 확인할 수 있습니다.

print(Child.mro())
-------------------RESULT---------------
[<class '__main__.Child'>, <class '__main__.Parents'>, <class '__main__.Aparents'>, <class '__main__.Gparents'>, <class 'object'>]

모든 결정 과정을 설명드리긴 힘들지만, 일반적으로 왼쪽에서 오른쪽, 아래에서 위로 진행합니다. 위의 경우는 다음과 같이 해석될 수 있습니다.

그러나 너무 꼬이면 다음과 같이 뜰 수 있습니다.

TypeError: Cannot create a consistent method resolution order (MRO) for bases A, C

한 가지 짚고 가면 좋을 점은 MRO의 가장 낮은 우선순위에 object클래스가 있다는 점입니다.(모든 클래스는 Python과 Java에서 Object 클래스를 상속합니다. C++은 int와 같은 자료형 클래스를 상속합니다.)

이러한 순서는 생성자, 소멸자에게도 비슷하게 적용됩니다. 하지만, 소멸자의 경우 그 순서가 반대가 됩니다.

이렇게 super에 맛을 들여버리니 C++에도 super를 쓰고 싶어집니다. 하지만, C++에는 현재로선 super가 없습니다. typedef로 super를 정의해서 super::과 같이 사용하는게 가능하기는 합니다. 다만, 각 클래스마다 부모 클래스를 super로 typedef로 정의해야 하는 번거로움이 있습니다.

한편, C++에는 friend라는 독특한 키워드가 존재합니다.

# include <iostream>

using namespace std;

class Me{
private:
  void pricelessMethod(){
    cout << "cis-Diamminedichloroplatinum(II)" << endl;
  }

  friend class Bfriends;  //C++11의 경우 friend Bfriends; 도 허용
};

class Bfriends{
public:
  void say(){
    Me mf;
    mf.pricelessMethod();
  }
};

int main(){
  Bfriends f;
  f.say();
}

위와 같이 friend class Bfriends; 문장을 통해 (일방적인) 친구 관계가 형성되었습니다. 따라서, private으로 정의된 Method에 접근할 수 있게 됩니다. (참고로 친구의 친구는 친구가 아니고, A가 B를 친구로 생각해도, B는 A를 친구로 생각하지 않을 수도 있습니다. 마찬가지로 자식의 친구는 친구가 아니고, 부모의 친구도 친구가 아닙니다.)

friend키워드는 함수에도 사용할 수 있습니다.

# include <iostream>

using namespace std;

class Me{
private:
  string str1 = "Cisplatin";
  void pricelessMethod(){
    cout << "cis-Diamminedichloroplatinum(II)" << endl;
  }

  friend void say(int num1);
};

void say(int num1){
  Me me;
  cout << num1 << " " << me.str1 << endl;
  me.pricelessMethod();
}

int main(){
  say(300);
}

-------------출력 결과--------------
300 Cisplatin
cis-Diamminedichloroplatinum(II)

클래스 내부의 메소드에 friend 키워드를 적용하는 것도 가능합니다. 단, 서로 일부분에만 적용하는 것은 불가능하며, 한쪽은 일부, 한쪽은 전체에 적용해야만 합니다.

예시 코드는 다음과 같습니다.

class Me{
friend class Myfriend;
public:
  string str1 = "Cisplatin";
  void printer();// 사용하려면 먼저 선언되어야 해서 미리 선언만 했습니다.
};

class Myfriend{
friend void Me::printer();
private:
  void lineMake(){
    cout << "-----------" << endl;
  }
};

void Me::printer(){
  Myfriend mf;
  cout << "cis-Diamminedichloroplatinum(II)" << endl;
  mf.Myfriend::lineMake();
}

int main(){
  Me me;
  me.printer();
}
================RESULT================
cis-Diamminedichloroplatinum(II)
-----------

이러한 friend 키워드는 간편해보이지만, 어떻게 보면 객체 지향적 프로그래밍과 대치되는 모습(접근을 제한하기는 커녕 private으로 처리한 내용까지 접근을 허용함)을 보여주기에, 되도록 사용하지 않는게 좋으며 실제로 다른 언어에서도 존재하지 않는 경우가 많습니다.

[프로그래밍] 5.4 클래스(4) - 클래스의 상속 (1)

StudyingCobble — Tue, 12 Nov 2019 01:27:43 +0900

※이 글은 프로그래밍 언어에 대한 기초적인 이해를 가정하고 있습니다. 최소 프로그래밍 언어 하나 정도를 약간이라도 접해보시는 것을 추천합니다. 또한, 이 글은 심화 내용은 되도록 피하여 서술했습니다.

클래스의 상속은 객체 지향 언어를 통해 프로그래밍에 걸리는 시간과 관리의 편의성을 늘리기 위해 필수적입니다. 기존의 클래스의 기능을 물려받으면서 새로운 클래스를 만들어야 할 때, 상속의 개념을 이용할 수 있습니다.

'상속'의 의미를 강조하기 위해(기업이나 유산의 상속 등의 느낌을 강조하기 위해) 화살표 방향을 위와 같이 사용하였지만, 실제 주로 사용되는 다이어그램은 위와 같은 형태로 그려지지 않습니다.

이러한 관계는 한 클래스가 한 클래스 만을 상속받는 왼쪽 그림과 같은 형태일수도 있고, 한 클래스가 여러 클래스를 상속받는 형태일수도 있습니다. 다만, 오른쪽과 같은 여러 클래스를 상속하는 경우는 C++, Python에서 가능하지만, Java에서는 불가능합니다. (오른쪽과 같은 경우 에러가 발생하는 경우 찾기도 힘들고, 그런 경우가 많기에 Java에서는 자체적으로 지원하지 않는 것 같습니다.)

다음 코드들은 여러 언어에서 상속이 어떻게 이루어지는지 보여줍니다.

# include <iostream>

using namespace std;

class Parents{
public:
  Parents(){
    cout << "Parents init" << endl;
  }
protected:
  void justPrinter(){
    cout << "Into the unknown" << endl;
  }
};

class Child : public Parents{
public:
  Child(){
    cout << "Child init " << endl;
    justPrinter();
  }
};

int main(){
  Child ch;
}


------------------RESULT-------------------
Parents init
Child init
Into the unknown

class parents:
    def __init__(self):
        print("Parents init")
    def __justPrint__(self):
        print("Into the unknown")

class child(parents):
    def __init__(self):
        print("Child init")
        self.__justPrint__()

ch = child()

------------------RESULT----------------------
Child init
Into the unknown

public class HelloWorld {
    public static void main(String[] args) {
      Child ch = new Child();
    }
}

class Parents {
  public Parents(){
    System.out.println("Parents init");
  }
  protected void wannaPrint(){
    System.out.println("Into the unknown");
  }
}

class Child extends Parents {
  public Child() {
    System.out.println("Child init");
    this.wannaPrint();
  }
}

----------------RESULT-------------------------
Parents init
Child init
Into the unknown

위 코드에서 알 수 있는 점은 다음과 같습니다.

(1) 클래스 상속을 위해 사용되는 코드는 언어마다 다르다.

C++

class Child : public Parents
(뒷 부분의 public은 나중에 설명하겠습니다.)

Python

class child(parents)

Java

class Child extends Parents

(2) 상속한 클래스의 생성자가 실행될 때 C++, Java는 생성자는 부모 클래스의 생성자를 먼저 실행하고, 자녀 클래스의 생성자를 실행한다.

(3) 상속한 메소드는 마음대로 (protected된 것까지도. private은 불가능) 자식 클래스에서 사용가능하다. (물론 property도!)

(4) Python은 부모 클래스의 생성자를 가져오지만, 자녀 클래스에도 생성자가 있으면 덮어쓰기되어, 자녀 클래스 생성자만 실행된다.

예시 코드로 부터 상속은 메소드와 멤버 변수와 같은 클래스의 모든 멤버를 (별도로 지정하지 않는 한) 상속함을 확인하였습니다. 그리나 Python을 제외하곤, 생성자가 일반적인 메소드의 개념이 아니기 때문에 각 클래스의 고유한 영역으로 남아있는 점을 확인할 수 있었습니다.

만약, 여기서 생성자가 인수를 받는다면 어떻게 될까요? 이 부분은 언어마다 내용이 상이한 관계로 언어별로 다루겠습니다.

먼저, Python입니다.

class parents:
    def __init__(self,num1):
        print(1+num1)

class child(parents):
    def __init__(self,num1):
        print(num1)

ch = child(10)
---------RESULT-------------
10

Python은 생성자 역시 하나의 메소드처럼 취급되는 만큼, 겹치는 부분에 대해서는 자식의 생성자가 우선이 되어 위와 같은 결과를 내놓습니다.

만약, 둘 다 표시하고 싶다면, 다음과 같이 메소드 오버라이딩을 위한 키워드인 super를 이용해줍니다. (super키워드의 자세한 용법은 다음 글에서 다룹니다.)

class parents:
    def __init__(self,num1):
        print(1+num1)

class child(parents):
    def __init__(self,num1):
        super().__init__(num1+10)
        print(num1)

ch = child(10)
-----------RESULT-----------------
21
10

C++의 경우에는 생성자가 상속되지 않기 때문에, 다음의 코드는 에러가 납니다.

# include <iostream>

using namespace std;

class Parents{
public:
  Parents(int m_num1){
    int num1 = m_num1;
    cout << "Parents init" << num1 << endl;
  }
};

class Child : public Parents{
public:
  Child(int m_num2){
    int num2 = m_num2;
    cout << "Child init " << num2 << endl;
  }
};

int main(){
  Child ch(10);
}

어쨌든 Parents 생성자에도 인수를 전달해야 하는데, 인수가 따로 전달되지 않아 에러가 발생합니다. 이 경우, 생성자만 따로 상속을 해주어야 합니다.

Child클래스만 다음과 같이 바꿔주면, 그 아래와 같은 결과가 얻어집니다.

class Child : public Parents{
public:
  Child(int m_num2) : Parents(m_num2+10){
    int num2 = m_num2;
    cout << "Child init " << num2 << endl;
  }
};

Parents init 20
Child init 10

계속하려면 아무 키나 누르십시오 . . .

이때 클래스 상속과 다르게, 뒤에 생성자가 오며, 생성자에 값을 집어 넣어주면서 전달해줌을 볼 수 있습니다.

Java에서도 비슷하게 다음과 같은 코드는 에러를 발생시킵니다.

class Parents {
  public Parents(int num2){
    System.out.println("Parents init"+num2);
  }

}

class Child extends Parents {
  public Child(int num1) {
    System.out.println("Child init"+num1);
  }
}

이를 위해 super를 이용해 값을 위로 전달해주게 됩니다.

public class HelloWorld {
    public static void main(String[] args) {
      Child ch = new Child(20);
    }
}

class Parents {
  public Parents(int num2){
    System.out.println("Parents init"+num2);
  }

}

class Child extends Parents {
  public Child(int num1) {
    super(num1-10);
    System.out.println("Child init"+num1);
  }
}

--------------RESULT---------------
Parents init10
Child init20

(super 키워드의 좀 더 다양한 사용법은 다음 글에서 다룹니다.)

하지만, 때로는 메소드를 단순히 가져오는 것이 아닌 바꿔서 사용하거나 기능을 더해야할 경우도 생길 것입니다. 이 경우 오버라이딩(Overriding)을 이용하게 됩니다. 관련 내용은 다음 글에 이어서 작성하겠습니다.

[프로그래밍] 5.3 클래스(3) - 생성자와 소멸자

StudyingCobble — Sat, 9 Nov 2019 14:22:50 +0900

프로그래밍으로 클래스를 사용하다보면, 인스턴스에 사용된 변수들을 초기화하거나, 초기 설정을 해야할 상황이 생깁니다. 이럴 때 생성자라는 개념을 활용할 수 있습니다. 생성자는 말 그대로 인스턴스가 생성될 때 자동으로 호출되는 메소드를 말합니다. 또한, 이에 대응되는 개념으로 인스턴스가 소멸할 때(메모리에서 해제될 때) 호출되는 소멸자라는 개념도 있습니다.

생성자와 소멸자는 다음과 같은 이름을 가진 메소드로 정의됩니다.

	C++	Java	Python
생성자 Constructor	(클래스 이름과 동일) ex) 클래스 명이 Test이면 Test		__init__ (언더바 2개가 양 끝에 위치)
소멸자 Destructor	~(클래스 이름) ex) ~Test	finalize	__del__

Python예제를 한번 봐봅시다.

class Test:
    def __init__(self,name : str ,height : int):
        self.name = name
        self.height = height
    def strAdd(self):
        return self.name + " " + str(self.height)
    def __del__(self):
        print("I've done all of my work...")

test = Test("James",170)
print(test.strAdd())

--------------------Result---------------
James 170
I've done all of my work....

보시다시피 함수에 인수를 전달하듯이 인스턴스를 생성하며 인수를 전달해 주니, 자동으로 생성자가 이를 초기화 해서 strAdd메소드를 호출할 때 두 값이 더해져서 반환 된 것을 확인할 수 있습니다. 그리고 할 일을 마친 소멸자는 마지막에 한 문장을 출력하게 되었죠.

위 코드에서 test = Test()라고만 써서 인수를 전달하지 않으면 다음과 같이 에러가 발생합니다.

I've done all of my work...
Traceback (most recent call last):
  File "E:\User File\My Files\Programming\Python\test.py", line 10, in <module>
    test = Test()
TypeError: __init__() missing 2 required positional arguments: 'name' and 'height'

~~(혼란을 틈타 호출된 소멸자)~~

인수가 필요하다는 에러가 뜨게 됩니다.

C++에서는 다음과 같이 써볼 수 있습니다.

# include <iostream>

using namespace std;

class TestCpp{
  public:
    int num1;
    int num2;
    
    TestCpp(int m_num1, int num2){
      num1 = m_num1;
  	  TestCpp::num2 = num2;
    }
    ~TestCpp(){
      printf("I did my best...");
    }
    int addTwo(){
      return num1 + num2;
    }
};

int main(){
	TestCpp test1(10,20);
	printf("%d\n", test1.addTwo());
}


--------------Result---------------------------
30
I did my best...

참고로 생성자와 소멸자에 Type이 없음에 주의해야 합니다! (또한 public으로 설정해야 합니다.) 위에서 argument로 사용된 변수랑 클래스 자체에 있던 변수랑 이름이 겹치므로 m_과 같이 접두사를 붙여 이름을 다르게 해주거나, 범위 지정 연산자 ::으로 지정해서 사용해야 합니다.(관련 내용은 이후 다루겠습니다)

그렇다면 과연 자바는 어떨까요??

public class HelloWorld {
    public static void main(String[] args) {
        TestClass test1 = new TestClass(10);
        test1.saySomething();
    }
}

class TestClass{
  public int num1;
  public TestClass(int num1){
    this.num1 = num1;
  }
  public void finalize(){
    System.out.println("Finalize called");
  }
  public void saySomething(){
    System.out.println(num1);
  }
}

(생성자는 타입이 없다는 점에 유의해주세요! 또한, public으로 생성자와 소멸자가 정의된 점을 유의해주세요!)

Python과 C++의 실행 결과를 바탕으로 아래와 같은 결과를 예상하실겁니다.

10
Finalize called

하지만, 일반적으로 다음의 결과를 얻을 것입니다.

이는 자바의 경우 Garbage Collection, 굳이 한글로 뜻을 바꿔보자면 쓰레기 수집이라는 것을 통해 필요없는 메모리를 해제할 때, finalize가 호출되는 데, 이 상황에서는 메모리 해제가 일어나지 않았음을 나타냅니다. 즉, 항상 호출되는 것은 아닙니다. 그렇다면, 어떻게 이 인스턴스를 쓰레기라고 인식하게 만들 수 있을까요?

굳이 항상 호출하고 싶다면, 위 코드에서 HelloWorld 클래스를 다음과 같이 바꾸면 됩니다.

public class HelloWorld {
    public static void main(String[] args) {
        TestClass test1 = new TestClass(10);
        test1.saySomething();
        test1 = null;
        System.gc();
    }
}

(System.gc()는 가비지 컬렉션을 진행하는 가비지 컬렉터를 호출합니다.)

test1에 null을 넣는 순간, test1은 TestClass의 인스턴스가 아니게 되어, 마치 빈 깡통과 같은 상태가 됩니다. 이 때 가비지 컬렉션을 호출한다면 다음과 같은 결과가 얻어집니다.

10
Finalize called

자바와 달리 C++은 이러한 가비지 컬렉션이 없기에, 소멸자는 인스턴스가 소멸될 때 수동으로 메모리를 해제하는 역할을 하기 위해 주로 사용됩니다. 그러나, 자바는 그럴 일이 별로 없기 때문에, 위와 같은 상황이 벌어집니다.

한편, C언어와 Java는 다음과 같은 생성자 오버로딩을 지원합니다. (Overloading) 이름은 같으나 받는 인수 개수가 다름에 유의하세요!

# include <iostream>

using namespace std;

class TestCpp{
public:
  TestCpp(int m_num1, int num2){
    printf("2 int argument\n");
  }
	TestCpp(int m_num1, int num2, int num3){
    printf("3 int argument\n");
  }
};

int main(){
	TestCpp test1(10,20);
	TestCpp test2(10,20,30);
}

-------------Result------------
2 int argument
3 int argument

public class HelloWorld {
    public static void main(String[] args) {
        TestClass test1 = new TestClass(10,20);
        TestClass test2 = new TestClass(10,20,30);
    }
}

class TestClass{
  public int num1;
  public TestClass(int num1, int num2){
    System.out.println("2 int");
  }
  public TestClass(int num1, int num2, int num3){
    System.out.println("3 int");
  }
}

-------------Result-------------
2 int
3 int

위와 같은 오버로딩은 상황에 따라 클래스를 여러가지로 초기화하는데 유용할 것입니다. Python의 경우 위와 같은 형식은 불가능하나, 가변 인수를 받음으로서 비슷한 코드를 작성할 수 있습니다. 아니면 위와 비슷한 코드를 아래와 같이 작성해볼 수도 있습니다.

class Test:
    def __init__(self, ar1 : int, ar2 : int = None):
        if ar2 == None:
            print("int 1")
        else:
            print("int 2")

test1 = Test(1)
test2 = Test(1,2)
---------Result--------------
int 1
int 2