바인딩 메모리관리 -...
80
Transcript of 바인딩 메모리관리 -...
속성(attributes)
속성(attributes)
~ 특성(properties)들의 집합
~ 변수의 위치(location)
값이 저장될 수 있는 공간, 컴퓨터 메모리 주소
~ 값(value)
저장 가능한 대상
~ 타입(data type)
저장되는 값의 범위(range) 결정
~ 명칭(= 식별자 = identifiers)
~ 영역(scope)
~ 존속기간(life-time)
~ …
const int n = 5 ;~ Q) 명칭 n 의 의미를 결정하는 것 ?
~ A) 속성
double func ( int n ) { … }
~ 매개변수 수, 매개변수 이름, 매개변수 자료형
~ 반환 자료형(return type), double
~ 함수 호출시 실행되는 코드 부분
int *y; (in C), y=new int; (in C++)~ 의미 ?
~ 기억 공간의 구조를 그림의 표현 ?
바인딩(Binding) ?
정의
~ 어떠한 대상(변수와 같은)과 성질(변수의 값과 같은)의 연결
~ 이름에 어떤 속성을 연결하는 과정
~ 속성과 개체의 결합, 연산과 기호의 결합, …
~ 프로그램의 기본 단위에 이 단위가 택할 수 있는 여러 속성
중에서 일부를 선정하여 결정하는 행위
종류
~ 정적 바인딩(static binding)
이름과 대상의 연결 작업이 실행시간 이전에 일어나는 바인딩.
~ 동적 바인딩(dynamic binding)
이름과 대상의 연결 작업이 실행시간에 일어나는 바인딩
바인딩이 발생되는 시점 ?
Example of Binding
6
// C++ example
int x, *y;
x = 2;
y = new int(3);
x Type: integer
Value: 2
y Type: integer pointer
Value: ∙ → 3
바인딩 시간(binding time)
바인딩 시간(binding time)
~ 실제로 바인딩이 일어나는 시간
바인딩 시간의 분류(categories)
~ 정적 바인딩(static binding)
실행 시간 이전에 일어나는 바인딩
~ 동적 바인딩(dynamic binding)
실행 시간에 일어나는 바인딩
Further Refined Binding Time
~ Language definition time
~ Language implementation time
~ Program translation time
~ Link time, Load time
~ Execution time (run time)
수식(expression)의 값
~ execution time if it contains variables
~ translation time if it is a constant expression
명칭(identifier)에 대한 자료형
~ translation time in a compilation system
C, C++, C#, Java, …
~ execution time in an interpreter
LISP, APL, SNOBOL4, …
정수(integer)
~ language definition time, 정수의 부분 집합
~ language implementation time, 최대 및 최소 범위
변수의 위치(location)
~ load time for static variables (static in C)
~ execution time for dynamic variables (auto in C)
구문 문제
이름 결정 규칙
~ 어휘 규칙(Lexical rules)에 의하여 이름 형태가 결정.
~ 예) C/Clite 언어 등
문자로 시작, …
대소문자 구분(Case sensitivity)
~ C언어 류 : yes
~ 초기의 언어들 : no
~ PHP: 부분적으로 구분 또는 비구분
예약어(reserved words), 지정어(keywords)
~ 특별한 의미를 가지는 명칭
~ 일반적인 명칭(변수 이름, 함수 이름 등)으로 사용할 수 없음
예약어
~ 미리 정의된 식별자의 예 : 라이브러리 함수명
명칭의 재정의, 예약어
~ 해로울까 ? Or 해롭지 않을까 ?
~ 예) C : typedef int Integer
Symbol Table and Environment
심볼 테이블(symbol table)
~ 번역/실행되는 동안 명칭에 적절한 의미 정보 부여/관리
~ 바인딩 정보를 저장하고 있는 언어 번역기의 자료 구조.
~ Mathematically, a function
SymbolTable: Names → Attributes
컴파일 시스템
~ 다양한 속성이 다양한 함수에 의해 유지
심벌 테이블 : Names → (Some) 정적 속성
환경 : Names → 메모리 위치(locations)
메모리 : Locations → Values
해석(interpretation) 시스템
~ 정적 및 동적 속성이 모두 실행 시간에 계산
~ 심벌 테이블과 환경이 조합
환경 : Names → Attributes
선언(declarations)
선언 : 바인딩을 구성하는 중요한 방법
~ 묵시적(implicit) 바인딩
~ 명시적(explicit) 바인딩, 명확한 지정
~ Example( in C )
int x;
the type binding is an explicit binding
the location binding is an implicit binding
초기값
묵시적 선언
~ 명칭 사용 규칙(naming convention)
~ FORTRAN example
the variable whose name starts with I, J, K, L,
M, or N is implicitly an integer
~ BASIC example
~ the trailing % of variable means an integer, $
means a string
Different Terms for Declarations
정의(definition)
~ a declaration that binds all potential attributes
~ 모든 잠재적인 속성을 바이딩하는 선언
선언(declaration)
~ a declaration that binds only a part of attributes
~ 속성 일부분만을 바인딩하는 선언
함수 선언( in C )
double f(int x) ;
~ 원형(prototype)
함수 f의 데이터 타입(매개변수 타입, 반환형)만 기술
구현 몸체는 기술하지 않음.
binds only the type (the interface) of the
function
블록과 지역성
블록(block)
~ 선언과 문장들의 연속으로 구성된 언어 구조
~ 할당의 단위(unit of allocations)
선언과 참조의 지역성(locality)
~ 지역적(local):
명칭에 대한 선언과 참조가 동일 블록으로 제한
~ 비지역적(non-local)
the declaration of a name is not in the block
which contains the reference for the name
void p (void)
{
double r, z; /* p 블록 */
…
{
int x, y; /* 내포된 블록 */
x = 2; y = 0; x += 1;
}
…
}
블록 구조화(Block-Structured)
블록 구조화 프로그램
~ 중첩될 수 있는 여러 개의 블록으로 구성된 프로그램
~ Algol60에서 시도
~ 후손 언어에서 블록 구조를 다양한 방법으로 제공
~ 순차 블록 : Pascal
~ 비순차 블록 : Ada, C
21
-- Ada example
declare x: integer;
begin
…
end
(* Pascal example *)
program ex;
var x: integer
begin
…
end
구조화 자료형(Structured Data Type)
~ a type declaration which contains declarations
내포된 선언(nested declaration)
~ 구조체 in C, 클래스 in C++, Java, Smalltalk
모듈(Module) or 패키지(Package)
~ a collection of declarations
~ the collection itself is not a declaration
Ada: package and task
Java: package
ML and Haskell: module
C++: namespace
영역, 스코프(Scope)
바인딩의 영역(Scope of a Binding)
~ 바인딩이 유지되는 범위, 위치가 중요 정보
~ 선언에 의해 결정된 바인딩이 동일 영역 유지, 선언의 영역
이름의 영역(Scope of a Name)
~ 동일 이름이 중복되어 선언될 수 있음 => 위험
~ these different declarations of the same name
should be differentiated
영역 규칙(Scope Rules)
정적(static) 영역 규칙
~ 블록 영역이 선언을 포함하고 있는 블록내부로 제한
~ 대부분의 블록 구조 프로그램은 정적 영역 규칙을 따름
동적(dynamic) 영역 규칙
~ 바인딩 영역이 실행 경로(path)에 따라 결정
~ 심볼 테이블이 동적으로 정보를 유지
Lexical Scope Example (C)int x;
void p(void)
{ char y;
...
} /* p */
void q(void)
{ double z;
...
} /* q */
main()
{ int w[10];
...
}
25
wmain
q
p
x
z
y
In C, the declaration
before use rule apply.
Scope Holes
영역 구멍(scope hole) ?
~ 명칭의 지역 선언은 동일한 이름의 이전(prior) 선언을 마스
크(mask) 함.
~ 마스크된 선언은 해당 블록 전체에 대해 영역 구멍을 갖음.
가시성(visibility)
~ 선언된 명칭의 바인딩이 적용되는 부분(영역 구멍 배제)
영역(scope)
~ 바인딩이 존재하며 가시성이 숨겨진 영역 포함(영역구멍 포
함)
int x;
void p(void)
{
char x;
x = ‘a’; /* char x에 배정 */
…
} /* p */
main()
{
x = 2; /* 전역 x에 배정 */
...
}
Scope Resolution Operator// C++ example
int x;
void p(void)
{
char x;
x = 'a'; // local x
::x = 42; // global x
...
} /* p */
main()
{
x = 2; // global x
...
}
The global integer
variable x has a scope
hole in the body of p.
In C, the global x
cannot be referenced in
p.
In C++, the global x can
be referenced in p
using a scope
resolution operator ::.
Ada also has a scope
resolution operator ..
File Scope in C
File Scope
~ In C, a global name can be turned into a file scope name by attaching the keyword static.
~ A file scope name can only be referenced in that file.
29
extern int x;
...
x
...
File 1
int x;
...
x
...
File 2
static int x;
...
x
...
File 3
Java Scope Example
public class Scope {
public static void f() {
System.out.println(x);
}
public static void main(String[] args) {
int x = 3;
f();
}
public static int x = 2;
}
클래스 선언( in Java )
~ 선언의 영역을 클래스 전체
출력되는 값 ?
~ the above code prints 2.
~ under dynamic scope rule, the code would print
3.
동적 스코프(dynamic scope)
동적 스코드의 단점(disadvantages)
~ 선언의 영역이 정적으로 결정되지 않음.
~ 선언의 영역을 결정하기 위해 Hand-simulation 수행.
~ 명칭의 자료형이 정적으로 결정될 수 없음.
~ 정적 자료형 검사(static type-checking) 불가능
Next chapters …
Symbol Table Maintenance
심볼 테이블이란 ?
~ 명칭에 연관된 모든 속성을 저장하는 공간
~ 효율적인 삽입, 검색, 삭제 연산 방법
~ 효율적 접근과 유지를 위한 자료구조
해쉬 테이블, 트리, 연결 리스트, …
정적 영역(lexically scoped languages)
~ 심볼 테이블이 스택과 같은 방법으로 운영
블록 진입시 모든 선언을 처리하여 대응하는 바인딩 추가
블록 진출시 선언에 의해 제공된 모든 바인딩 제거, 복구
~ 심볼 테이블 운영이 실행 경로(순서)와 무관.
33
ST under Lexical Scopeint x;
char y;
void p(void)
{ double x;
...
{ /* block b */
int y[10];
...
}
...
}
void q(void)
{ int y;
...
}
main()
{ char x;
...
}
34
xint
global
ycharglobal
xint
global
pvoid
function
ycharglobal
xint
global
pvoid
function
ycharglobal
xint
globaldoublelocal to p
pvoid
function
xint
globaldoublelocal to p
ycharglobal
int[10]local to b
pvoid
function
ycharglobal
xint
globaldoublelocal to p
pvoid
function
ycharglobal
xint
global
pvoid
function
ycharglobal
xint
global
qvoid
function
pvoid
function
xint
global
qvoid
function
ycharglobal
intlocal to q
pvoid
function
ycharglobal
xint
global
qvoid
function
pvoid
function
ycharglobal
xint
global
qvoid
function
mainint
function
pvoid
function
ycharglobal
qvoid
function
mainint
function
xint
globalchar
local to main
pvoid
function
ycharglobal
xint
global
qvoid
function
mainint
function
ST under Dynamic Scope#include <stdio.h>
int x = 1;
char y = 'a';
void p(void)
{ double x = 2.5;
printf("%c\n",y)
{ /* block b */
int y[10];
}
}
void q(void)
{ int y = 42;
printf("%d\n",x);
p();
}
main()
{ char x = 'b';
q();
return 0;
}
35
pvoid
function
ychar='a'
global
qvoid
function
mainint
function
xint=1global
pvoid
function
ychar='a'
global
qvoid
function
mainint
function
xint=1global
char='b'local to main
pvoid
function
ychar='a'
global
qvoid
function
mainint
function
xint=1global
char='b'local to main
int=42local to q
pvoid
function
ychar='a'
global
qvoid
function
mainint
function
xint=1global
char='b'local to main
int=42local to q
98Output
ASCII value of 'b'
pvoid
function
ychar='a'
global
qvoid
function
mainint
function
xint…
char…
int=42local to q
98Output
double=2.5local to p
pvoid
function
ychar='a'
global
qvoid
function
mainint
function
xint…
char…
int=42local to q
double=2.5local to p
98
*Output
ASCII 42 = 'b'
동적 영역(dynamically scoped languages)
~ 가장 바깥쪽의 명칭의 바인딩이 구성.
~ 바인딩이 프로그램 실행 경로에 따라 유지
비지역 변수 참조에 대해 적용된 실행 순서 추적 방법 ?
비지역 변수의 참조가 실행 이전에 예측할 수 없음.
다중적재(overloading)
다중적재 ?
~ 서로 다른 엔티티에 대해 명칭을 재사용
~ 같은 이름을 사용하여 프로그램의 다른 대상을 참조
~ 3+4 vs. 3.0+4.0
어셈블리 언어 : ADDI, ADDF
번역기는 피연산자의 자료형을 참고
~ 연산자 중복(operator overloading)
C++
~ 함수 중복(function overloading)
C++, Java
the operator + is overloaded
~ integer addition (say, ADDI)
~ floating point number addition (say, ADDF)
How about mixed-type expression?
~ 2 + 3.2
~ C/C++ : promotion (implicit type conversion).
~ Ada : Error.
Signature
~ 반환형, 매개변수 개수, 매개변수 자료형
int max(int x, int y) // max #1
{ return x > y ? x : y; }
double max(double x, double y) // max #2
{ return x > y ? x : y; }
int max(int x, int y, int z) // max #3
{ return x > y ? (x > z ? x : z) : (y > z ? y : z); }
Name resolution
~ max(2,3) // calls max #1
~ max(2.1,3.2) // calls max #2
~ max(1,3,2) // calls max #3
Overload Resolution Issues
묵시적 자료형 변환은 모호한(ambiguous) 호출
~ max(2.1, 3) // max ???
~ C++: too many candidates (max #1 or max #2)
~ Ada: no candidates
~ Java: 묵시적 자료형 변환은 정보 손실이 없는 경우로 제한
다중 적재에서 반환형의 고려 여부 ?
~ 함수의 반환형을 함수 호출 정보로 포함할것인가 ?
~ C++, Java: not included
~ Ada: included
Function Overloading in Adaprocedure overload is
function max(x: integer; y: integer) -- max #1
return integer is
begin
...
end max;
function max(x: integer; y: integer) -- max #2
return float is
begin
...
end max;
a: integer;
b: float;
begin -- max_test
a := max(2,3); -- call to max # 1
b := max(2,3); -- call to max # 2
end overload;
41
In Ada, the return type is
included in the calling
context.
Operator Overloading in C++#include <iostream>
using namespace std;
typedef struct { int i; double d; } IntDouble;
bool operator < (IntDouble x, IntDouble y)
{ return x.i < y.i && x.d < y.d; }
IntDouble operator + (IntDouble x, IntDouble y)
{ IntDouble z;
z.i = x.i + y.i;
z.d = x.d + y.d;
return z;
}
int main()
{ IntDouble x = {1, 2.1}, y = {5, 3.4};
if (x < y) x = x + y;
else y = x + y;
cout << x.i << " " << x.d << endl;
return 0;
}
Operator Overloading in Adaprocedure opover is
type IntDouble is
record
i: Integer;
d: Float;
end record;
function "<" (x,y: IntDouble) return Boolean is ...
function "+" (x,y: IntDouble) return IntDouble is ...
x, y: IntDouble;
begin
x := (1,2.1);
y := (5,3.4);
if (x < y) then x := x + y;
else y := x + y;
end if;
put(x.i); put(" "); put(x.d); new_line;
end opover;
명칭의 재사용
Reusing names for different kinds of
entities
~ Separate name space for each kind is needed.
~ These kinds of reusing is not an overloading.
44
typedef struct A A;
struct A
{ int data;
A * next;
};
C example
class A
{ A A(A A)
{ A:
for(;;)
{ if (A.A(A) == A)
break A;
}
return A;
}
}
Java example
structure tag
nametype name
Which is which?
• class name
• method name
• parameter name
• label name
실행 환경(Environment)
환경
~ 명칭과 위치(location)를 연결시키는 것.
환경 결정 시간
~ 정적 환경 : FORTRAN
~ 동적 환경 : LISP
~ 혼합(mixture) : most Algol-style languages
모든 명칭이 환경에 연결되는 것은 아님.
~ 상수
~ Const int MAX = 10;
변수에 대한 기억 장소 할당 시간
~ 전역 변수(global variable)
~ 정적 기억 장소 할당
~ 로딩 시간(load time)에 기억 장소 할당
~ 지역 변수
~ 동적 기억 장소 할당
~ 제어가 도달할 때 선언된 변수에 대한 기억 장소 할당
전형적인 실행 환경의 구조
정적 영역(static area)
~ static allocation
스택 영역(stack)
~ LIFO-style dynamic allocation
~ 정적 기억 장소 할당
힙 영역(heap)
~ on-demand dynamic
allocation
~ 동적 기억 장소 할당
활성화 레코드(Activation Record)
활성화(Activation)
~ 부 프로그램 호출을 호출하면 ?
~ 각 부프로그램 호출(invocation or activation)에 대해
각 부프로그램에 대한 환경에 구축되어야 함.
활성화 레코드(Activation Record; AR)
~ 부프로그램 호출에 대해 할당되는 메모리 공간
~ subprogram environment + bookkeeping
information
실행시간 스택(Run-Time Stack)
~ 블록의 진입과 진출이 LIFO 방식으로 운용
~ 프로시쥬어 호출과 반환이 LIFO 방식으로 운용
~ 활성화 레코드들이 실행시간 스택에 저장.
Run-Time Stack Manipulation
A: { int x;
char y;
B: { double x;
int a;
} /* end B */
C: { char y;
int b;
D: { int x;
double
y;
} /* end D
*/
} /* end C */
} /* end A */
50
point 1
Run-Time Stack Manipulation
A: { int x;
char y;
B: { double x;
int a;
} /* end B */
C: { char y;
int b;
D: { int x;
double y;
} /* end D */
} /* end C */
} /* end A */
51
point 2
Run-Time Stack Manipulation
A: { int x;
char y;
B: { double x;
int a;
} /* end B */
C: { char y;
int b;
D: { int x;
double y;
} /* end D */
} /* end C */
} /* end A */
52
point 3
Run-Time Stack Manipulation
A: { int x;
char y;
B: { double x;
int a;
} /* end B */
C: { char y;
int b;
D: { int x;
double y;
} /* end D */
} /* end C */
} /* end A */
53
point 4
Run-Time Stack Manipulation
A: { int x;
char y;
B: { double x;
int a;
} /* end B */
C: { char y;
int b;
D: { int x;
double y;
} /* end D */
} /* end C */
} /* end A */
54
point 5
힙(heap) 메모리 영역 관리
힙 메모리(Free Store) 할당
~ 객체(objects)의 할당에 대해 지원되는 메모리 구역(pool)
환경에서 선언 처리의 결과로 생기는 할당된 기억장소 구역
~ 동적 메모리 공간
힙 메모리 반환(deallocation)
~ 사용을 마친 힙 메모리 구역에 대한 반환 함수 또는 연산자
사용
free() in C, delete in C++, Ada.
~ 자동 반환(automatic deallocation)
garbage collector 사용
안전하기는 하지만 속도 저하의 문제점, in Java
Pointer and Dereferencing
포인터
~ 다른 객체의 위치(=주소)를 값으로 갖는 객체.
~ int *x = NULL;
x는 할당된 객체를 가리키기 위해 수동으로 객체 할당
x = ( int * ) malloc( sizeof( int ) ) ;
참조 인출(dereferencing)
~ 주소(pointer value)를 통한 객체 참조.
/* C example */
int *x; // pointer declaration
x = (int*)malloc(sizeof(int)); // memory allocation
*x = 5; // dereferencing
printf(“%d\n”, *x);
free(x); // deallocation
/* C++ example */
int* x = new int;
*x = 2;
cout << *x << endl;
delete x;
/* Java example */
Integer x = new Integer(2);
System.out.println(x);
// delete 연산이 필요 없음.
생명시간(Lifetime)
객체(storable object)
~ a chunk of memory cells
~ 환경에서 할당되는 기억 장소 구역(area of storage)
객체의 생명 시간(lifetime or extent)
~ 환경에서 기억 장소가 할당되어 소멸까지의 소요 시간
생명시간(lifetime) vs. 영역(scope)
~ 변수에 대한 생명시간과 영역은 밀접한 관련은 있지만 동일
하지 않음.
~ local static variables in C/C++
영역 : local, global
생명시간 : static, dynamic
Local Static Variable Example (C)
int p(void) {
static int p_count = 0;
p_count += 1;
return p_count;
}
main() {
int i;
for (i = 0; i < 10; i++) {
if ( p() % 3 ) printf("%d\n", p() );
}
return 0;
}
변수와 상수
변수(variable)
~ 실행시간 동안 변환되는 값을 저장하는 객체(=기억공간)
~ 명칭이 실제 메모리 주소로 변환 (언제: ).
상수(constants)
~ 생명시간 동안 변하지 않는 객체의 값
~ an object whose value does not change for its
lifetime
리터럴(literals)
~ 명칭에 의해 값이 명확하게 정해지는 객체
L-value and R-value
L-value and R-value
~ l-value (LHS value): the location
~ r-value (RHS value): the value stored
~ X=10(○), x=y(○), 100 = z (×).
배정(assignment)
배정
~ 변수의 값을 변경하는 가장 기본적인 방법
~ variable assingmentOpertor expression (중위법)
~ 값의 복사(value-copying)에 의한 배정
~ 포인터에 의한 배정(pointer semantics)
공유에 의한 배정(shallow copying)
복제에 의한 배정(deep copying)
☞ 복제(cloning)
객체를 메모리에 정확히 복사
복제(cloning)에 의한 배정
변수의 값(value)과 위치(location)가 복제.
~ x = y
~ 새로운 위치를 할당하여 y의 값을 복사
~ 새로 할당된 위치를 x에 바인딩
Java Example
Java supports
~ 공유에 의한 배정
assignment of object variables
~ 값-복사에 의한 배정
assignment of simple data
~ 복제에 의한 배정
메소드 복제(method clone.)
상수(constant) Semantics
상수 다이어그램
상수의 의미(semantics)
~ 바인딩이 결정되면 실행중 변화가 없음.
~ 상수의 위치는 참조되지 않음.
값만 유지하고 위치 속성을 갖지 않음.
상수의 분류
리터널 and Named Constants
~ literals: 값을 표현하는 명칭
~ named constants: 값의 의미에 대한 명칭
Named Constants 분류
~ 정적 상수( = 상수)
실행 이전에 값이 계산될 수 있는 상수
컴파일 시간(compile-time) 정적 상수,
적재 시간(load-time) 정적 상수
~ 동적 상수
실행하는 동안에만 값이 계산되는 상수
상수 초기화
C ~ the initial value of a static constant (or a static
variable) should be computed from literals only
C++~ the above restriction is removed
72
#include <stdio.h>
#include <time.h>
const int a = 2;
const int b = 27+2*2; /* legal in C */
const int c = (int) time(0); /* illegal C code! */
int b = 27+a*a; /* also illegal in C */
별칭(Aliases)
별칭(aliases)
~ 동일 객체에 대해 동시에 두 개 이상의 명칭을 접근
~ 프로그램 판독성 저하
~ 부작용(harmful side effects) 발생
부작용(side effect)
~ 문장의 실행 이후에 변수의 값이 변경되는 것.
잠정적으로 해로운 부작용
~ 부작용을 작성된 문장을 통해서는 결정하기 어려움
~ 실행되는 문장의 앞 부분을 참고해야 알 수 있음.
An Example of Harmful Aliases
main()
{ int *x, *y;
x = (int *) malloc(sizeof(int));
*x = 1;
y = x; /* *x and *y now aliases */
*y = 2;
printf("%d\n",*x);
return 0;
}
별칭의 발생 요인 ?
별칭의 발생 요인 ?~ 포인터 배정문(pointer assignment)
~ 참조에 의한 매개변수 전달(call-by-reference parameters)
~ 공유에 의한 배정(assignment by sharing)
75
class ArrTest {
public static void main(String[] args) {
int[] x = { 1, 2, 3};
int[] y = x;
x[0] = 42;
System.out.println( y[0] );
}
}
// int[] y = (int[]) x.clone();
허상 참조(dangling references)
허상 참조~ 할당된 기억 장소 반환, 접근 경로(=포인터) 존재.
~ 객체에 대해 환경에서 수명 종료, 접근 경로 존재
~ Dangerous !
허상 참조를 만드는 요인 ?~ pointer assignment and explicit deallocation
~ pointer assignment and implicit deallocation
by block exit
by function exit
Example of Dangling References
main(){
int *x, *y;
x = (int *) malloc(sizeof(int));
*x = 1;
y = x; /* *x and *y now aliases */
free(x); /* *y now a dangling reference */
printf("%d\n",*y); /* illegal reference */
return 0;
}
쓰레기(Garbage)
Garbage (Dangling Objects)~ 할당된 기억 장소는 존재하지만 접근 경로가 없음.
~ 할당된 기억 장소가 너무 늦게 반환
~ 메모리 낭비 발생, but 해롭지는 않음.
쓰레기는 만드는 요인 ?~ 명확한(explicit) 기억 장소 할당, 접근 경로 분실
Assignment
deallocation of the access point
An Example of Garbage
main()
{ int *x;
x = (int *) malloc(sizeof(int));
x = 1; /* OOPS! */
...
return 0;
}
Garbage Collection
언어 시스템~ automatically reclaims garbage.
함수 언어, 객체지향 언어~ using garbage collectors.
See you in Memory management section !!
![[XECon2016] A-1 정규창 [React] Immutable한 양방향 데이터 바인딩](https://static.fdocument.pub/doc/165x107/588025f81a28ab9f0f8b4655/xecon2016-a-1-react-immutable-.jpg)
![Lecture01: 유닉스/리눅스소개 - compiler.sangji.ac.krcompiler.sangji.ac.kr/lecture/linux/2018/lecture01.pdf · 유닉스버전트리[위키백과] Lecture 01: Unix & Linux,](https://static.fdocument.pub/doc/165x107/5e185fe1ed687542ef6715d8/lecture01-oeeeeoeeoe-oeeeeoeee-lecture.jpg)
