KR100624512B1 - 객체지향성 프로그래밍 구현을 위한 방법 및 이를 위한 구조체가 저장되는 메모리 - Google Patents

Abstract

1. 청구범위에 기재된 발명이 속한 기술분야

객체지향성 프로그램 언어에 관한 것이다.

2. 발명이 해결하려고 하는 기술적 과제

C를 이용하여 자바와 같이 객체지향성을 가지도록 한다.

3. 발명의 해결방법의 요지

본 발명의 요지는 멤버변수를 가지는 최상위클래스구조체와, 최상위클래스를 상속한 클래스의 정보와 구현한 인터페이스정보를 포함하여 구성된 최상위클래스정보구조체와, 객체 내의 변수와 메소드를 정의하기 위한 것으로 C언어의 구조체를 이용하여 상기 변수와 메소드를 정의하고, 하나의 부모클레스구조체를 상속하는 클래스구조체와, 상기 부모클래스구조체의 부모클래스정보구조체를 상속하며, 상기 클래스구조체의 타입정보와 상속정보, 인터페이스정보, 재정의정보를 포함하는 클래스정보구조체 및, 하나 이상의 메소드를 구비하는 인터페이스구조체를 포함하는 것을 특징으로 한다.

4. 발명의 중요한 용도

휴대용정보단말기와 같이 시스템 자원이 열악한 상황에서도 객체지향성을 가지는 언어의 구현에 이용된다.

OOP, 객체지향, C, 오브잭트

Description

객체지향성 프로그래밍 구현을 위한 방법 및 이를 위한 구조체가 저장되는 메모리{Method for realizing Object Orient Programing and Memory for Storing Structure for the Same}

도1a와 1b는 클래스구조체와 클래스정보구조체의 구조와 실제 선언 예를 나타낸 도면이다.

도2는 트리구조를 가지는 클래스의 상속 개념을 도시한 도면이다.

도3a 및 3b는 " ParentClass" 클래스를 " MyClass" 클래스가 상속하는 것을 도시한 도면이다.

도4a 및 4b는 인터페이스의 구성과 예를 나타낸 도면이다.

도5는 두개의 인터페이스 " ParentInterface1" , " ParentInterface2" 를 상속하는 인터페이스 " MyInterface" 를 나타낸 도면이다.

도6은 MyClass 클래스가 " MyInterface1" , " MyInterface2" 인터페이스를 구현하는 예를 나타낸 도면이다.

도7a는 정적 클래스 초기화를 나타낸 도면이다.

도7b는 동적 클래스 초기화를 나타낸 도면이다.

도8은 ParentInterface1, ParentInterface2, ParentInterface3 인터페이스를 상속하는 MyInterface의 인터페이스 등록함수 예를 나타낸 도면이다.

도9a는 MyClass의 클래스 인스턴스 생성함수의 예를 나타낸 도면이다.

9b는 하나의 클래스가 인스턴스화 되었을 때 클래스가 메모리 상에 만들어지는 모습을 나타낸 도면이다.

도10a 및 10b는 클래스의 멤버를 접근하는 예를 나타낸 도면이다.

도11은 인터페이스 멤버를 접근하기 위한 처리와 인터페이스의 멤버를 접근하는 방법을 나타낸 도면이다.

도12a 와 12b는 MyClass의 인스턴스에서 MyInterface의 멤버변수 b를 접근하는 방법을 나타낸 도면이다.

도13은 클래스정보구조체의 포인터를 설정하는 방법과 이를 접근하는 예을 나타낸 도면이다.

도14는 MyClass가 MyMethod 라는 재정의 가능한 함수를 제공하는 예를 나타낸 도면이다.

도15는 MyInterface가 MyMethod 라는 인터페이스 메소드를 제공하는 예를 나타낸 도면이다.

도16은 본 발명에 따른 동작을 설명하기 위한 개략적인 블록 구성도이다.

도17은 본 발명에 따른 동작 제어를 위한 제어 흐름도이다.

도18은 본 발명에 따른 정적초기화를 위한 제어 흐름도이다.

도19는 본 발명에 따른 동적초기화를 위한 제어 흐름도이다.

도20은 본 발명에 따른 인터페이스의 등록을 위한 제어 흐름도이다.

도21은 본 발명에 따른 인터페이스의 초기화를 위한 제어 흐름도이다.

본 발명은 객체지향성을 가지는 프로그램에 관한 것으로, 특히 C언어의 구조체를 이용한 객체지향성 프로그래밍 구현을 위한 방법 및 이를 위한 구조체가 저장되는 메모리에 관한 것이다.

일반적으로 객체지향성프로그래밍(Object Oriented Programming) 언어는 C, Pascal, Basic과 같이 순차적인 동작을 실행하는 절차형 언어(procedure-oriented programming)와는 달리 모든 데이터를 오브젝트(object: 이하 " 객체" 라 함)로 취급하여 크고 복잡한 프로그램이 가능한 언어이다. 객체는 특정 클래스 또는 그 클래스의 자체 메쏘드(Method)나 데이터 변수를 가지고 있는 자식클래스가 실제로 구현된 것, 즉 인스턴스로 실제로 컴퓨터 내에서 수행되는 것을 말한다.

이러한 객체지향성을 가지는 언어로는 C++, JAVA 등이 있으며 대형의 프로그램이 가능하도록 하며, 유지관리가 용이한 장점이 있다.

그러나, 이러한 객체지향성을 가지는 언어는 이의 원활한 동작을 위하여 하드웨어적으로 높은 시스템 성능을 요구하고 있다. 따라서, 시스템 성능이 좋지 않은 소형기기나 낮은 시스템 성능을 지닌 기기에서는 객체지향언어로 프로그래밍 된 어플리케이션이 원활하게 동작되지 못하는 문제점이 있다.

C, Pascal, Basic과 같이 순차적인 동작을 실행하는 절차형 언어(procedure-oriented programming)는 높은 시스템 사양을 요구하고 있지는 않으나 객체지향성 이 없기 때문에 대형프로그램의 개발이나 개발 이후의 유지관리가 용이하지 않은 문제점이 있다.

본 발명은 상술한 문제점을 해결하기 위한 것으로 높은 시스템 사양을 요구하지 않으면서 객체지향성을 가지는 C언어의 구조체를 이용한 객체지향성 프로그래밍 구현을 위한 방법 및 이를 위한 구조체가 저장되는 메모리를 제공함을 목적으로 한다.

본 발명은 멤버변수를 가지는 최상위클래스구조체와, 최상위클래스를 상속한 클래스의 정보와 구현한 인터페이스정보를 포함하여 구성된 최상위클래스정보구조체와, 객체 내의 변수와 메소드를 정의하기 위한 것으로 C언어의 구조체를 이용하여 상기 변수와 메소드를 정의하고, 하나의 부모클레스구조체를 상속하는 클래스구조체와, 상기 부모클래스구조체의 부모클래스정보구조체를 상속하며, 상기 클래스구조체의 타입정보와 상속정보, 인터페이스정보, 재정의정보를 포함하는 클래스정보구조체 및, 하나 이상의 메소드를 구비하는 인터페이스구조체를 포함하는 것을 특징으로 한다.

이하 첨부한 도면을 참조하여 본 발명을 설명한다.

도1a와 1b는 클래스구조체와 클래스정보구조체의 구조와 선언 예를 나타낸 도면이고, 도2는 트리구조를 가지는 클래스의 상속 개념을 도시한 도면이며, 도3a 및 3b는 " ParentClass" 클래스를 " MyClass" 클래스가 상속하는 것을 도시한 도면이고, 도4a 및 4b는 인터페이스의 구성과 예를 나타낸 도면이며, 도5는 두개의 인 터페이스 " ParentInterface1" , " ParentInterface2" 를 상속하는 인터페이스 " MyInterface" 를 나타낸 도면이고, 도6은 MyClass 클래스가 " MyInterface1" , " MyInterface2" 인터페이스를 구현하는 예를 나타낸 도면이며, 도7a는 정적 클래스 초기화를 나타낸 도면이고, 도7b는 동적 클래스 초기화를 나타낸 도면이며, 도8은 ParentInterface1, ParentInterface2, ParentInterface3 인터페이스를 상속하는 MyInterface의 인터페이스 등록함수 예를 나타낸 도면이고, 도9a는 MyClass의 클래스 인스턴스 생성함수의 예를 나타낸 도면이며, 9b는 하나의 클래스가 인스턴스화 되었을 때 클래스가 메모리 상에 만들어지는 모습을 나타낸 도면이며, 도10a 및 10b는 MyClass가 클래스의 멤버를 접근하는 예를 나타낸 도면이고, 도11은 MyInterface 를 구현하는 MyClass 클래스를 예로 들어 인터페이스 멤버를 접근하기 위한 처리와 인터페이스의 멤버를 접근하는 방법을 나타낸 도면이며, 도12a 와 12b는 MyClass의 인스턴스에서 MyInterface의 멤버변수 b를 접근하는 방법을 나타낸 도면이고, 도13은 클래스정보구조체의 포인터를 설정하는 방법과 이를 접근하는 예을 나타낸 도면이며, 도14는 MyClass가 MyMethod 라는 재정의 가능한 함수를 제공하는 예를 나타낸 도면이고, 도15는 MyInterface가 MyMethod 라는 인터페이스 메소드를 제공하는 예를 나타낸 도면이며, 도16은 본 발명에 따른 동작을 설명하기 위한 개략적인 블록 구성도이고, 도17은 본 발명에 따른 동작 제어를 위한 제어 흐름도이며, 도18은 본 발명에 따른 정적초기화를 위한 제어 흐름도이고, 도19는 본 발명에 따른 동적초기화를 위한 제어 흐름도이며, 도20은 본 발명에 따른 인터페이스의 등록을 위한 제어 흐름도이고, 도21은 본 발명에 따른 인터페이스의 초기화를 위한 제어 흐름도이다.

객체지향성 언어는 식별(Identity), 분류(Classification), 다형성(Polymorphism), 상속(Inheritance)과 같은 특성을 지닌다. 이를 설명하면 다음과 같다.

식별 특성은 각각의 객체는 다른 객체로부터 분리되어 있고, 분별 가능해야 한다는 것이다.

분류 특성은 같은 자료구조와 행위를 가지는 객체들은 동일한 클래스(class)로 분류되는 것을 말한다. 상대적으로 각 객체는 소속 클래스의 인스턴스(instance)가 된다. 같은 클래스에서 생성된 객체들은 모두 같은 연산(operation) 기능을 갖고 있으며, 자료구조가 같고 동일한 행위를 하게 된다. 자료구조는 객체들이 갖는 데이터와 속성(attribute)들의 집합이다.

다형성의 특성은, 같은 연산 기능이 부여되어도 그 기능을 수행하는 클래스에 따라 다른 행위로 나타날 수 있는 것을 말한다. 예를 들어 '이동(move)' 이라는 기능이 '영희'라는 클래스에 적용될 때는 소풍이 될 수 있으나, '승용차'라는 클래스에 적용되면 특정 목적지로 일정한 시각에 정해진 속도로 움직이는 행위가 될 수도 있다.

상속 특성은 계층(hierarchy, 슈퍼-서브, 상-하, 부모클래스-자식클래스)관계에 놓여 있는 클래스들 간에 속성이나 연산 기능들을 공유하는 것을 말한다. 즉, 주어진 클래스에 부모클래스가 있다면 자식클래스의 모든 객체들은 소속 클래스의 모든 속성이나 연산기능을 상속받게 된다. 따라서, 자식클래스를 정의할 때에는 부 모클래스(super class)로부터 상속받는 내역들을 중복하여 정의할 필요가 없게 된다.

위에서 언급하고 있는 객체지향성언어들의 특성 중에 식별(Identity), 분류(Classification), 다형성(Polymorphism)은 프로그램 개발 시에 프로그래머에 의한 조정이나 객체의 사용에 따라 구현될 수 있다. 그러나, 상속(Inheritance) 특성은 단순한 사용자의 조정이나 객체의 사용에 의해서 이루어지지 못하는 문제점이 있다.

본 발명은 이러한 객체지향성언어에서 특히, 상속 및 다형성의 특성을 구현할 수 있도록 한 방법 및 이의 구조에 관한 것이다. 이를 위하여 본 발명은 C언어의 구조체를 이용한 것으로, 객체지향성 프로그래밍 개념 중에서 클래스, 인터페이스, 클래스 상속, 클래스 메소드 재정의, 인터페이스 상속, 인터페이스 구현, 인터페이스 메소드 구현 등을 C 언어로 표현하고 운용한 것으로 이를 상세히 하기에 설명한다.

객체지향성 프로그래밍에서 클래스는 특정 종류의 객체 내에 있는 변수와 메쏘드(Method)를 정의하는 일종의 틀(template)로 본 발명에서는 도1a와 1b에서와 같이 클래스구조체와 클래스정보구조체의 짝으로 구성된다.

본 발명에서, 최상위 클래스를 제외한 모든 클래스는 단 하나의 부모클래스를 가지도록 한다. 즉, 단일 상속만을 허용한다. 다중 상속을 하지 않는 이유는 프로그램이 복잡해지고, 처리 속도가 느려질 수 있기 때문이다. 다중 상속은 클래스를 만드는 방법에 있어서 많은 선택권을 주지만 클래스의 정의를 복잡하게 할 수 있다.

본 발명의 실시예에서 클래스구조체의 이름은 "T"로 시작되며 클래스정보구조체의 이름은 "IT"로 시작되도록 하였다. 예를들어 " MyClass" 라는 클래스는 " TMyClass" 라는 클래스구조체와 " ITMyClass" 라는 클래스정보구조체로 구성된다.

1. 클래스구조체

클래스구조체는 클래스가 상속한 부모클래스구조체와 클래스가 구현한 인터페이스구조체, 그리고 클래스 멤버변수를 포함하며 클래스가 실제로 인스턴스화 될 때 사용된다. 부모클래스구조체는 모든 클래스가 반드시 하나만 포함해야 한다. 단, 모든 클래스의 최상위 클래스의 클래스구조체에는 부모클래스구조체가 포함되지 않는다. 인터페이스구조체는 해당 클래스가 어떤 인터페이스를 구현할 경우만 포함되며 클래스 멤버변수는 클래스의 기능에 따라 필요한 만큼 포함된다.

2. 클래스정보구조체

클래스정보구조체는 클래스구조체가 클래스 타입이 무엇이고, 어떤 클래스를 상속했는지, 어떤 인터페이스를 구현했는지, 그 클래스가 제공하는 재정의(오버라이딩) 할 수 있는 함수의 포인터 등의 정보를 알려주기 위한 것이다. 즉, 클래스를 인스턴스로 만들어 사용할 때에 어떤 클래스를 상속하고, 어떤 인터페이스를 구현했는지 알기 위해 클래스정보구조체가 필요하다.

클래스정보구조체의 클래스구조체에 클래스정보구조체의 내용을 포함시킬 수도 있지만, 이렇게 나누어 놓은 이유는 클래스구조체는 클래스가 인스턴스화 될 때 메모리(힙 : 52)상에 만들어지므로 모든 정보가 클래스구조체에 포함되면 비교적 메모리가 적은 단말에서는 많은 메모리 낭비를 초래하게 된다. 따라서, 프로그램이 수행될 때 변할 수 있는 항목들은 클래스구조체에 넣고 프로그램이 수행될 때 변하지 않은 항목들은 클래스정보구조체에 넣어서 클래스구조체의 크기를 줄여서 메모리를 아낄 수 있다. 문서 도9b를 보면 클래스정보구조체는 하나의 정적 변수로 선언되어 램(RAM : 50) 상에 위치하며 클래스구조체가 메모리(HEAP : 52)상에 생성되었을 때 참조되기만 한다.

클래스 A 가 있고 클래스 A 가 메소드 F 제공하고 메소드 F 는 클래스 A 의 객체만을 인수로 받는다고 가정하면,

F(a); a: 클래스 A 의 객체(인스턴스)

위 호출이 유효한지를 메소드 F 가 내부적으로 확인한다. 왜냐하면 메소드 F 는 클래스 A 의 클래스구조체의 멤버변수를 사용하기 때문이다. 만일 클래스 A 의 객체가 아닌 다른 클래스의 객체가 인수로 전달되었다면 그 클래스의 클래스구조체는 클래스 A 의 클래스구조체와 다른 모양을 하고 있기 때문에 메소드 F 가 사용하고자 하는 멤버변수의 값을 올바로 가져올 수 없다.

이때, 사용되는 것이 클래스정보구조체(정확히 최상위 클래스의 클래스정보구조체)에 포함되어 있는 클래스타입리스트 이다. 클래스타입리스트는 정적 클래스 초기화 루틴에서 하나씩 추가되어 해당 클래스가 상속한 모든 클래스의 타입을 가지게 된다. 위 예에서는 이 클래스타입리스트에 클래스 A 에 해당하는 클래스타입이 있는지를 체크하면 된다.

구현한 인터페이스에 대한 정보는 어떤 클래스 객체가, 인터페이스가 제공하 는 메소드의 인수로 전달되었을 때 그 메소드 내부에서 전달된 객체가 특정 인터페이스를 구현했는지 여부를 확인할 때 사용된다.

클래스정보구조체는 부모클래스정보구조체와 클래스의 정적인 멤버변수나 클래스 메소드의 포인터를 포함하며 시스템이 초기화되는 시점에서 한번만 초기화된다. 부모클래스정보구조체는 모든 클래스가 반드시 하나만 포함해야 한다. 단, 최상위 클래스의 클래스정보구조체에는 부모클래스정보구조체가 포함되지 않는다. 클래스정보구조체는 정적 멤버변수와 메소드 포인터를 클래스의 기능에 따라 필요한 만큼 포함한다.

도1a와 1b는 클래스구조체와 클래스정보구조체의 구조와 실제 선언 예를 나타낸 도면이다.

3. 최상위 클래스

최상위 클래스는 모든 클래스의 최상위에 위치하는 클래스를 말한다. 최상위 클래스는 부모클래스를 가지지 않는다.

최상위클래스구조체에는 클래스정보구조체를 참조하는 멤버변수가 포함되며 이 멤버변수를 이용하여 클래스정보구조체의 정보를 접근할 수 있도록 한다.

최상위클래스정보구조체에는 해당 클래스가 상속한 클래스에 대한 정보와 구현한 인터페이스의 정보가 포함되며 이 정보를 이용하여 클래스가 인스턴스화(객체)되어 사용될 때 어떤 클래스의 인스턴스인지 어떤 인터페이스를 구현하였는지에 대한 정보를 얻는다.

4. 클래스 상속

클래스 상속은 부모클래스의 클래스구조체를 자식클래스의 클래스구조체가 포함하고, 부모클래스의 클래스정보구조체를 자식클래스의 클래스정보구조체가 포함하는 형태로 구현된다.

최상위클레스를 제외한 모든 클래스는 부모클래스를 가져야 한다. 전술한 바와 같이 최상위 클래스는 부모클래스가 존재하지 않는다. 또한, 클래스 상속은 단일 상속만을 지원하며 다중 상속을 지원하지 않는다. 최상위 클래스를 제외한 모든 클래스가 부모클래스를 가지고 단일 상속을 함으로써, 도2와 같이 최상위 클래스부터 시작되는 트리구조를 이룬다.

클래스가 클래스를 상속하는 방법은 아래와 같은 원칙 하에 이루어진다.

1) 부모클래스구조체 변수를 자식클래스구조체의 최상위에 포함시킨다.

2) 부모클래스정보구조체변수를 자식클래스정보구조체의 최상위에 포함시킨다.

도3a 및 3b는 " ParentClass" 클래스를 " MyClass" 클래스가 상속하는 것을 보여준다.

5. 인터페이스

인터페이스는 0 개 이상의 부모인터페이스를 가질 수 있다. 인터페이스는 인터페이스만을 상속할 수 있다. 인터페이스는 인터페이스 메소드 프로토타입만을 가지며 인터페이스를 구현하는 클래스가 모든 인터페이스 메소드를 실제로 구현해야 한다.

인터페이스는 객체에 대한 정의가 아니라 하나 또는 그 이상의 객체가 구현 할 메소드 집합의 정의이다. 이것은 인터페이스를 구현한 클래스의 객체가 인터페이스에서 정의한 메소드를 강제로 구현하도록 한다. 이렇게 함으로써, 해당 인터페이스를 구현한 클래스 객체는 반드시 그 인터페이스가 제공하는 함수를 구현하게된다.

이를테면, 클래스 A, B 가 있고, 클래스 A 의 객체 a, 클래스 B 의 객체 b 가 있으며, 인터페이스 I 는 F 라는 메소드를 정의했을 경우...

"메소드 F 에는 반드시 인터페이스 I 를 구현한 클래스 객체만이 인수로 사용될 수 있다."

F(객체 a); 라는 호출은 유효한가?

F(객체 b); 라는 호출은 유효한가?

위 두 질문에서 유효한지 여부를 판단할 수 있는 근거가 될 수 있는 유일한 방법이 객체 a 의 클래스 A 가 인터페이스 I 를 구현하였는지를 확인하는 방법이다. 왜냐하면 "메소드 F 에는 반드시 인터페이스 I를 구현한 클래스 객체만이 인수로 사용될 수 있다." 고 했기 때문이다.

만일 클래스 A 가 인터페이스 I를 구현하였다면 상기와 같이 메소드 F 는 올바른 수행을 하고 그렇지 않을 경우 에러를 발생시킨다. 클래스 B 도 같은 방법으로 확인할 수 있다.

결론적으로 말하면 "어떤 클래스가 인터페이스 I 를 구현했다면 그 클래스의 객체는 메소드 F 를 사용할 수 있다."

실제 사용예를 들어보면

화면에 그리기와 관련된 메소드 집합( Draw(), Redraw(),... )을 가지는 Drawable 이란 인터페이스가 있고, 화면에 그려질 수 있는 모든 클래스(Lable, List, Popup, 등등)는 Drawable 이란 인터페이스를 구현한다.

그리고, 어떤 객체를 화면에 그리도록 할 때 Draw(객체) 메소드를 호출한다. Draw() 메소드는 내부적으로 인수로 전달된 객체가 Drawable 인터페이스를 구현하였는지 확인하고 구현했을 경우 정상적으로 그리기를 수행하며 구현하지 않았을 경우 에러를 발생시킨다.

이를 정리하면 다음과 같다.

모든 그려질 수 있는 클래스들은 Drawable 인터페이스를 구현했으므로, 모든 화면에 그려질 수 있는 클래스들은 Draw() 메소드를 사용할 수 있다.

6. 인터페이스 선언

인터페이스는 인터페이스구조체로 표현된다. 인터페이스구조체는 부모인터페이스구조체와 인터페이스 멤버변수 그리고 인터페이스 메소드포인터를 포함한다. 부모인터페이스구조체는 인터페이스가 상속한 인터페이스가 있을 경우에 포함되며 없을 수도 있다. 인터페이스 멤버변수는 인터페이스의 기능에 따라 필요한 만큼 포함된다. 인터페이스 메소드 포인터 또한 인터페이스의 기능에 따라 필요한 만큼 포함된다. 그러나 인터페이스는 인터페이스를 구현하는 클래스가 반드시 인터페이스의 모든 메소드를 구현하도록 정의하므로 인터페이스 메소드는 1개 이상 포함된다. 도4a 및 4b는 인터페이스의 구성과 예를 나타낸 것이다.

7. 인터페이스 상속

인터페이스 상속은 인터페이스가 인터페이스를 상속하는 것을 의미하며 하나 이상의 인터페이스를 상속할 수 있다. 즉, 인터페이스는 다중상속을 지원한다. 인터페이스가 인터페이스를 상속하는 방법은 아래와 같은 원칙 하에 이루어진다.

1) 상속하려는 인터페이스들의 인터페이스구조체 변수를 상속받는 인터페이스의 인터페이스구조체의 최상위에 차례로 포함시킨다.

도5는 두개의 인터페이스 " ParentInterface1" , " ParentInterface2" 를 상속하는 인터페이스 " MyInterface" 를 보여준다.

8. 인터페이스 구현

인터페이스 구현은 클래스가 인터페이스를 상속하는 것을 말하며 하나의 클래스가 여러 개의 인터페이스를 구현할 수 있고, 모든 클래스는 0개 이상의 인터페이스를 구현할 수 있다. 인터페이스 구현은 클래스구조체에 인터페이스구조체를 포함하는 방식으로 이루어지며 아래와 같은 원칙 하에 이루어진다.

1) 구현하고자 하는 인터페이스들의 인터페이스구조체 변수를 부모클래스구조체 변수의 바로 아래에 차례로 위치시킨다.

도6은 MyClass 클래스가 " MyInterface1" , " MyInterface2" 인터페이스를 구현하는 예를 보여준다.

9. 클래스 초기화

모든 클래스는 클래스가 사용되기 전에 초기화 과정을 거쳐야 한다. 클래스를 초기화하는 것은 클래스구조체와 클래스정보구조체 내부의 멤버변수들을 적절한 값으로 초기화하기 위한 것입니다. 도7a 및 7b를 보면 정적 클래스 초기화와 동적 클래스 초기화 단계에서 각 구조체 멤버변수들의 값이 변경되는 것을 볼 수 있다.

클래스의 초기화 과정은 클래스정보구조체를 초기화하는 정적인 초기화 단계와 클래스구조체를 초기화하는 동적인 초기화 단계로 이루어진다.

1) 정적 클래스 초기화

정적 클래스 초기화는 클래스정보구조체를 초기화하는 과정을 말한다. 이 과정은 시스템이 초기화되는 시점에서 한번만 수행되며 클래스정보구조체 내의 정적 멤버변수와 메소드포인터를 초기화하고 필요할 경우 부모 또는 부모클래스의 메소드를 재정의 한다. 모든 클래스는 정적 클래스 초기화를 위해서 정적 클래스정보구조체 변수와 정적 클래스 초기화 함수를 제공하며 모든 인터페이스는 인터페이스 등록을 위해 인터페이스 등록함수를 제공한다.

아래는 정적 클래스 초기화 함수가 수행하는 일과 그 순서를 나타낸다. 초기화 과정에서 정적 클래스정보구조체 변수가 사용된다.

클래스정보구조체는 전역변수로 선언되어 램(50)에 위치하게된다.

정적클래스 초기화 시에 다음과 같은 초기화 작업이 이루어집니다.

(1) 부모클래스 정적 클래스 초기화 함수 호출

(2) 클래스타입 추가

(3) 구현한 인터페이스들의 인터페이스 등록함수를 호출한다.

(4) 인터페이스 등록

(5) 부모클래스 메소드 재정의

(6) 정적멤버변수 초기화

도7a를 살펴보면, 최상위클래스정보구조체의 클래스타입리스트와 인터페이스정보리스트에 해당 클래스와 인터페이스의 정보가 추가되며 메소드 참조변수들이 가리키는 함수들이 변경된다. 부모클래스의 메소드 참조변수는 기본적으로 부모자신의 메소드를 가리키게 되지만 자식클래스가 재정의 하게 되면 자식클래스의 메소드를 가리키게 된다.

2) 동적 클래스 초기화

동적 클래스 초기화는 클래스구조체를 초기화하는 과정을 말한다. 이 과정은 클래스가 인스턴스화 되는 시점에서 수행되며 구현한 인터페이스가 있을 경우 그 인터페이스의 초기화 루틴을 호출하고 클래스구조체 내의 멤버변수를 초기화한다. 모든 클래스는 동적 클래스 초기화를 위해서 동적 클래스 초기화 함수를 제공한다.

아래는 동적 클래스 초기화 함수가 수행하는 일을 나타낸다. 순서는 필요에 의해 바뀌어질 수 있다. 초기화 과정에서는 동적으로 메모리(40, 50)에 할당된 클래스구조체 변수가 사용된다.

1) 부모클래스의 동적 클래스 초기화 함수를 호출한다.

2) 구현한 인터페이스의 인터페이스 초기화 함수를 호출한다.

3) 클래스의 멤버변수를 초기화한다.

부모클래스의 동적 클래스 초기화 함수를 호출하는 것은 최상위 클래스에서는 생략된다.

동적 클래스 초기화는 클래스인스턴스를 생성할 때 수행되며 메모리(HEAP) 상에 할당된 클래스구조체를 초기화하는 것이다.

클래스인스턴스를 저장할 변수(클래스구조체 포인터)는 전역변수 혹은 지역변수로 선언되며 전역변수로 선언될 경우는 메모리(램 : 50) 상에 생성되며 지역변수로 선언될 경우는 스택(51)에 생성된다.

클래스인스턴스를 생성하는 과정은 다음과 같다.

(1) 클래스구조체변수를 HEAP 에 할당

(2) 부모클래스의 동적 클래스 초기화 함수 호출

(3) 인터페이스메소드 구현

(4) 멤버변수 초기화

이때 최상위 클래스의 멤버변수 초기화 과정에서 클래스정보구조체의 참조변수를 설정한다.

도7b에 빨간색으로 표시된 부분은 클래스인스턴스가 생성되는 시점에서 초기화되는 것을 나타낸 것이다.

클래스인스턴스를 저장할 변수는 클래스 인스턴스 생성함수(new클래스())가 반환하는 값이 설정되는 것이다.

10. 인터페이스 등록

인터페이스의 등록은 어떤 클래스가 해당 인터페이스를 구현했는지에 대한 확인을 위해서 클래스정보구조체에 해당 인터페이스에 대한 정보를 추가하기 위해 이루어진다.

모든 인터페이스는 사용되기 이전에 인터페이스를 등록해야한다. 이를 위해서 인터페이스 등록함수를 제공하며 클래스가 인터페이스를 구현했을 경우 해당 클 래스의 정적 클래스 초기화 함수에서 호출된다.

인터페이스 등록 함수는 인터페이스를 구현하는 클래스의 부모클래스의 클래스구조체 크기를 인수로 전달받으며 다음과 같은 일을 수행한다.

1) 상속한 인터페이스가 있을 경우 상속한 인터페이스들의 인터페이스 등록함수를 호출한다. 첫 번째로 상속한 인터페이스의 인터페이스 등록함수를 호출할 때에는 인수로 전달받은 부모클래스의 클래스구조체 크기를 인수로 전달한다. 다음 인터페이스부터는 부모클래스의 클래스구조체 크기에, 해당 인터페이스 이전에 포함된 인터페이스들의 인터페이스구조체 크기를 합한 값을 인수로 전달하여야 한다.

2) 인수로 전달받은 부모클래스의 클래스구조체 크기와 인터페이스 타입을 사용하여 인터페이스를 등록한다.

도8은 ParentInterface1, ParentInterface2, ParentInterface3 인터페이스를 상속하는 MyInterface의 인터페이스 등록함수 예를 나타낸 것이다.

11. 인터페이스 초기화

인터페이스를 구현하는 클래스의 클래스구조체에는 인터페이스구조체가 포함되어 있다. 클래스가 인스턴스화되는 시점에서 메모리에 할당된 클래스구조체의 멤버변수 값들은 초기화되지 않은 쓰레기값이 들어있다. 이러한 멤버변수의 초기값을 주는 것이 동적 클래스 초기화 루틴에서 수행된다. 인터페이스구조체 역시 멤버변수를 초기화해 주어야 한다. 인터페이스는 메소드 포인터를 가지는데 이것은 클래스가 구현해야 하는 메소드를 가리키는 포인터로서 인터페이스 초기화 시에 유효한 메소드를 가리키도록 한다.

인터페이스는 클래스가 인스턴스화되는 시점에서 초기화된다.

인터페이스 초기화 루틴은 인터페이스가 제공하는 인터페이스 메소드의 포인터를 초기화한다. 이를 위해서 모든 인터페이스는 인터페이스 초기화 함수를 제공하며 이 함수는 클래스가 구현해야 할 모든 메소드 포인터를 인수로 받는다.

다음은 인터페이스 초기화 함수가 수행하는 일을 기술한 것이다.

1) 인터페이스가 상속한 인터페이스들의 인터페이스 초기화 함수를 호출한다.

2) 인터페이스 메소드 포인터를 초기화한다. 이는 초기화 함수의 인수로 전달받은 클래스가 구현한 메소드 포인터로 치환한다.

3) 인터페이스의 멤버변수를 초기화한다.

12. 클래스 인스턴스 생성

시스템이 초기화되는 시점에서 모든 클래스의 정적 클래스 초기화 루틴이 수행되고 나면 클래스를 인스턴스화 시킬 수 있다. 클래스를 인스턴스화 시키기 위해 모든 클래스는 클래스 인스턴스를 생성시키는 클래스 인스턴스 생성 함수를 제공한다. 이 함수는 " new클래스" 명으로 명명되며 다음과 같은 일을 수행한다.

1) 클래스구조체의 크기만큼 메모리를 할당한다.

2) 최상위 클래스의 클래스정보구조체 포인터를 가지는 클래스구조체의 멤버 변수를 자신의 클래스정보구조체의 포인터로 설정한다. 즉, 최상위클래스구조체의 클래스정보구조체 참조변수를 자신의 클래스정보구조체의 포인터로 설정한다.

3) 할당받은 클래스구조체 포인터를 인수로 동적 클래스 초기화 함수을 호출 한다.

4) 초기화된 클래스구조체의 포인터를 반환한다.

도9a는 MyClass의 클래스 인스턴스 생성함수의 예를 나타내었다.

도9b는 하나의 클래스가 인스턴스화 되었을 때 클래스가 메모리 상에 만들어지는 모습을 나타낸 도면으로, 클래스와 인터페이스의 생성(구조체 선언)부터 시작하여 클래스 초기화, 인터페이스 등록, 클래스 인스턴스 생성 등의 모든 과정을 수행한 후의 모습으로 실제로 사용자가 클래스를 인스턴스화하여 사용되기 직전의 상태를 나타낸다.

13. 클래스 멤버 접근

클래스 객체는 클래스구조체의 포인터이다. 클래스구조체에는 클래스의 목적을 달성하기 위한 멤버변수가 있으며 이 멤버변수는 클래스 객체에서 사용되어질 수 있어야 한다.

예를 들면 화면에 사각형을 그리는 클래스가 있다고 가정하자. 이 클래스는 사각형의 범위를 저장하기 위해 좌상단 좌표 x1, y1 과 우하단 좌표 x2, y2 를 멤버변수로 가지며 이 멤버변수를 변경하거나 얻을 수 있는 메소드를 제공하며 또한 사각형을 그리는 메소드를 제공한다.

이러한 경우 사각형 범위를 저장하기 위하여 멤버변수 x1, y1, x2, y2 를 접근할 수 있어야 한다. 메소드 포인터 역시 하나의 멤버변수이며 이 역시 참조될 수 있어야 한다.

클래스 멤버 접근은 클래스구조체 또는 클래스정보구조체가 메모리 상에 생 성되었을 때 각 구조체의 멤버에 접근하는 것을 말한다. 클래스 멤버는 멤버변수나 메소드포인터를 말하며 모든 부모클래스의 멤버도 포함된다.

여기서는 이와 같은 클래스 멤버를 접근하는 방법을 설명하되 클래스구조체 위주로 설명한다. 클래스정보구조체의 멤버를 접근하는 방법도 클래스구조체와 같은 방식으로 한다.

1) 모든 클래스는 자신이 상속한 부모클래스의 클래스구조체를 자신의 클래스구조체의 최상위에 포함한다.

2) 모든 클래스구조체는 자신의 멤버변수를 접근할 때 자신의 구조체형식으로 형변환(type casting)을 하여 접근한다.

도10a 및 10b는 TAncestorClass 를 상속받은 ParentClass를 MyClass가 상속하여 클래스의 멤버를 접근하는 예를 보여준다.

14. 인터페이스 멤버 접근

인터페이스 멤버 접근은 클래스구조체가 메모리 상에 생성되었을 때 클래스가 구현한 인터페이스의 멤버에 접근하는 것을 말한다.

인터페이스 멤버는 인터페이스 멤버변수나 인터페이스 메소드포인터를 말하며 인터페이스가 상속한 모든 인터페이스의 멤버도 포함된다.

여기서는 이와 같은 인터페이스 멤버를 접근하는 방법을 설명한다.

1) 모든 클래스는 자신이 구현한 인터페이스들의 인터페이스구조체를 자신의 클래스구조체에 포함할 때 부모클래스의 클래스구조체 바로 아래에 차례로 포함시킨다.

2) 최상위 클래스는 인터페이스를 등록 받는 함수를 제공하며 이 함수는 클래스구조체 내에서 인터페이스구조체가 위치한 오프셋과 인터페이스 타입을 인수로 받고 이를 저장한다. 이 정보는 최상위 클래스의 클래스정보구조체에 저장된다.

3) 최상위 클래스는 인터페이스의 오프셋을 반환하는 함수를 제공하며 이 함수는 클래스 인스턴스와 인터페이스 타입을 인수로 받아 해당 클래스에 등록되어 있는 인터페이스 중 인수로 받은 인터페이스 타입과 일치하는 인터페이스의 오프셋을 찾아 반환한다.

4) 모든 인터페이스는 자신을 등록하는 인터페이스 등록 함수를 제공하며 이 함수는 클래스구조체 내에서 자신의 인터페이스구조체가 위치한 오프셋을 인수로 받고 이를 이용하여 자신을 등록한다.

5) 모든 클래스는 자신의 정적 클래스 초기화 함수에서 자신이 구현한 인터페이스가 있을 때 해당 인터페이스의 인터페이스 등록함수를 각각 호출해 주어야 한다. 이 때, 클래스구조체에서 해당 인터페이스의 인터페이스구조체가 위치한 오프셋을 인수로 전달하여야 한다.

5) 인터페이스 멤버를 접근할 때는 클래스구조체의 포인터(클래스 인스턴스)에서 해당 인터페이스의 오프셋을 더한 다음 자신의 인터페이스구조체 타입으로 형변환을 하여 접근한다.

도11은 MyInterface 를 구현하는 MyClass 클래스를 예로 들어 인터페이스 멤버를 접근하기 위한 처리와 인터페이스의 멤버를 접근하는 방법을 보여준다.

도12a 와 12b는 MyClass의 인스턴스에서 MyInterface의 멤버변수 b를 접근하 는 방법을 보여준다.

15. 클래스정보구조체 접근

클래스정보구조체에는 정적 멤버변수와 클래스 메소드 포인터를 가진다. 정적멤버변수의 예로 최상위 클래스의 클래스정보구조체에 포함되어 있는 클래스타입리스트를 들 수 있으며 이것은 어떤 객체가 어떠한 클래스를 상속하였는지에 대한 정보를 얻기 위해 접근이 가능해야 한다. 클래스 메소드 포인터에는 해당 클래스가 재정의한 메소드의 포인터가 저장되며 이러한 재정의된 메소드를 호출하기 위해서는 해당 클래스 메소드 포인터를 접근할 수 있어야 한다.

클래스의 클래스정보구조체는 각 클래스마다 정적으로 클래스정보구조체 변수를 선언하며 이 변수는 시스템이 초기화되는 시점에서 초기화된다. 이렇게 초기화된 클래스정보구조체는 해당 클래스가 상속한 클래스들의 정보와, 구현한 인터페이스들의 정보와, 재정의된 클래스 메소드의 정보를 가지게 된다. 이러한 정보는 클래스가 인스턴스화된 후에 접근될 수 있어야 한다. 여기서는 이러한 클래스정보구조체를 클래스 인스턴스가 접근하는 방법을 설명한다.

클래스정보구조체를 접근하기 위해서 다음과 같은 처리를 한다.

1) 최상위 클래스는 클래스구조체에 클래스정보구조체의 포인터를 가지는 멤버변수를 포함한다.

2) 클래스 인스턴스 생성 함수에서는 최상위 클래스의 클래스구조체 내의 클래스정보구조체의 포인터를 가지는 변수를 자신의 클래스정보구조체의 포인터로 치환한다.

도13은 최상위 클래스 TopClass 를 상속받는 MyClass를 예로들어 클래스정보구조체의 포인터를 설정하는 방법과 이를 접근하는 예을 나타낸 것이다.

16. 클래스 메소드 재정의

객체지향 개념에서 정의하고 있는 특성 중 하나인 다형성(Polymorphism)을 제공해 주기 위해, 메소드의 재정의(method overriding)를 할 수 있도록 한다. 상속관계에서 나타날 수 있는 다형성의 특징이 메소드 재정이다. 이러한 다형성은 보다 더 강력한 소스 코드 및 외부 인터페이스를 재사용 할 수 있도록 해 주고, 상위클래스의 일부 메소드가 하위클래스에 적합하지 않을 경우에도, 적합하지 않은 메소드만 재정의(overriding) 함으로써 상속이 가능하며 나머지 부분은 재사용 될 수 있다.

또한, 프로그램의 다른 부분이 수정 없이 재사용 되고, 응용 프로그램의 개발을 돕기 위한 뼈대 구조를 제공하는 강력한 클래스 라이브러리(패키지)를 제공할 수 있다. 하위클래스는 상위클래스로부터 상속되는 상태와 행동들을 가질 수 있다. 그리고, 하위클래스는 자신에게 필요한 변수들과 메소드를 추가적으로 정의할 수 있다. 하위클래스는 상위클래스에서 정의된 메소드와 같은 이름, 같은 인자들을 갖는 새로운 메소드를 정의하여 상위클래스에서 상속되는 메소드를 재정의(overriding)할 수 있다.

이렇게 하위클래스가 상위클래스의 메소드를 새로 구현함으로써 상위클래스에서 제공해주고 있는 메소드를 하위클래스에 맞게 새롭게 구현할 수 있다.

클래스 메소드 재정의는 부모클래스 또는 부모클래스의 메소드를 자식클래스 가 재정의 하는 것을 말하며 실제적으로 부모 또는 부모클래스의 클래스구조체에 있는 클래스 메소드 포인터를 재정의 하고자 하는 함수의 포인터로 대체하는 것을 의미한다.

클래스 메소드 재정의를 위해 각 클래스는 다음과 같은 기능 및 함수를 제공한다.

1) 클래스정보구조체에 재정의 할 수 있는 클래스 메소드 포인터를 선언한다.

2) 클래스정보구조체에 선언되어 있는 클래스 메소드 포인터를 치환하는 함수를 제공한다. 함수명은 " override_메소드명" 으로 명명한다.

3) 클래스정보구조체에 선언되어 있는 클래스 메소드 포인터가 가리키는 실제 함수를 호출해주는 함수를 제공한다.

도14는 MyClass가 MyMethod 라는 재정의 가능한 함수를 제공하는 예를 나타낸 것이다.

17. 인터페이스 메소드 구현

인터페이스 메소드 구현은, 클래스가 구현한 인터페이스에서 정의한 메소드를 구현하는 것을 말한다. 이는, 실질적으로 해당 인터페이스의 인터페이스구조체에 있는 인터페이스 메소드 포인터를 구현하고자 하는 함수의 포인터로 대체하는 것을 의미한다. 인터페이스 메소드 구현을 위해 각 인터페이스는 다음과 같은 기능 및 함수를 제공한다.

1) 인터페이스구조체에 구현되어야 하는 인터페이스 메소드의 함수 포인터를 선언한다.

2) 인터페이스구조체에 선언되어 있는 인터페이스 메소드 포인터를 치환하는 함수를 제공한다. 함수명은 " implements_메소드명" 으로 명명한다.

3) 인터페이스구조체에 선언되어 있는 인터페이스 메소드 포인터가 가리키는 실제 함수를 호출해주는 함수를 제공한다.

도15는 MyInterface가 MyMethod 라는 인터페이스 메소드를 제공하는 예를 나타낸 것이다.

이하 도 16을 참조하여 본 발명에 따른 개략적인 블록 구성을 설명한다.

(★ 도 16의 설명에서 각각의 구성(사용자 프로그램, 정적초기화부, 인스턴스 생성자, 롬, 램)에 대한 단편적인 설명만을 부가하였으나 이의 상세한 설명(역할, 주요동작)을 부탁드립니다.)

도 16에서 사용자프로그램유닛(10)은 일반적인 메인 프로그램으로 정적초기화부(20)로 정적초기화를 요구하며, 다수의 인스턴스생성자(31, 32, 33...)에게 각각의 클래스에 대한 인스턴스화를 요구하며 리턴값에 따라 해당 동작을 제어 및 수행한다.

정적초기화부(20)는 사용자프로그램(10)으로부터의 정정초기화 요구에 응답하여 각각의 클래스에 대한 초기화를 수행한다.

롬(40)은 클래스별로 컴파일된 해당 데이터, 다수의 메소드를 저장하고 있다.

램(50)은 스택(Stack : 51)과 힙(Heap)을 포함하고 있으며, 힙(52)은 인스턴 스화되는 클래스별로 클래스구조체가 메모리 할당되어 사용되며, 스택(51)이나 램(50)의 일정 영역은 자식클래스구조체의 포인터가 할당되어 저장된다.

도16 이하를 참조하여 본 발명에 따른 동작을 설명하면 다음과 같다.

도 17은 본 발명의 개략적인 동작을 나타낸 것으로 100 단계에서 시스템 초기화에 요구에 의해 사용자프로그램유닛(10)은 200 단계에서 정적초기화부(20)를 통해 클래스정보구조체를 초기화한다. 사용자 프로그램유닛(10)은 프로그램 시작시점에 클래스를 사용하기에 앞서 클래스 정적초기화를 정적초기화부(20)로 요청한다. 정적초기화과정에서는 각 클래스의 정적초기화 과정이 수정되며 매 초기화 과정에서 해당 클래스의 상속 정보와 인터페이스 구현정보 및, 상위 클래스의 메소드 재정의 과정이 수행된다. 정적초기화 과정은 각 클래스를 인스턴스화 해서 사용하기 전에 클래스에 대한 정보를 설정하기 위한 것으로 이 과정을 수행한 이후로는 어떠한 클래스든지 사용자 요청에 의해 클래스가 인스턴스화 되어 사용될 수 있다.

정적초기화 동작은 도 18a 및 18b를 참조하여 추후 상세히 설명한다.

정적초기화가 완료되면, 사용자프로그램유닛(10)은 도17의 300 단계로 진행하여 인스턴스생성자(31, 32, 33, ...)를 통해 클래스의 인스턴스화를 요구한다. 즉, 사용자프로그램유닛(10)로부터 객체생성요구가 있으면 인스턴스생성자(31, 32, 33,...)는 400 단계로 진행하여 클래스구조체 변수를 힙(52)에 할당한다. 즉, 도9b에 보여짐과 같이 할당한다. 사용자는 사용자의 목적에 맞는 클래스를 인스턴스화시켜 사용할 수 있다. 클래스를 인스턴스화시키기 위해서는 해당 클래스의 객체생성요구를 해야 하며 객체 생성 요구를 받은 인스턴스생성자(31, 32, 33, ...)는 해 당 클래스의 클래스구조체를 힙(52)에 할당한다.

이후, 500 단계에서 인스턴스생성자(31, 32, 33....)는 클래스인스턴스를 저장할 변수(클래스구조체 포인터)가 전역변수로 선언될 경우는 메모리(램 : 50) 상의 일정 영역에 생성하고, 지역변수로 선언될 경우는 스택(51)에 생성한다. 포인터의 설정이 완료되면, 600 단계에서 인스턴스 생성자(31, 32, 33....)는 동적초기화 동작을 수행한다.

동적초기화 동작은 할당된 클래스구조체의 포인터를 이용하여 해당 클래스의 동적초기화 과정을 수행하는 것으로 도 19를 참조하여 차후 상세히 설명한다.

동적초기화가 완료되면 700 단계로 진행하여 포인터를 사용자프로그램유닛(10)으로 반환한다.

이하, 정적초기화 동작을 도 18a 및 18b를 참조하여 하기에 상세히 설명한다.

18a의 210 단계에서 정적초기화부(20)는 사용자프로그램유닛(10)으로부터 정적초기화 요구가 있으면 정적초기화를 진행하고자 하는 클래스가 최상위클래스인지 판단한다. 최상위 클래스이면 230 단계로 진행하고, 그렇지 않으면 220 단계로 진행하여 해당 클래스의 부모클래스의 정적초기화를 수행한다. 정적초기화 과정은 모든 클래스가 인스턴스화되기 이전에 수행되어야 하는 과정으로 각 클래스가 상속한 부모클래스들에 대한 정보와 구현한 인터페이스들의 정보, 정적멤버변수의 초기화를 수행한다. 정적초기화 과정에서는 최상위클래스가 아닌 경우에만 부모클래스의 정적초기화 과정을 수행하며 이에 의해 최상위 클래스에 이르기까지의 모든 상위 클래스들이 정적초기화를 수행하게 된다(도2 참조). 해당 부모클래스의 정적초기화 과정을 마치게 되면 230 단계로 진행하여 클래스 타입을 추가하게 된다. 클래스 타입은 해당 클래스가 어떤 타입인지를 확인하기 위해 필요하다. 이후, 240 단계에서 정적초기화부(20)는 해당 클래스가 구현한 인터페이스가 있는지 검사한다.

구현한 인터페이스가 존재하면 250 단계로 진행하여 인터페이스 등록 루틴을 수행하게 된다. 인터페이스 등록 루틴은 해당 클래스가 구현한 인터페이스가 존재할 경우에만 수행한다. 이는 해당 클래스가 어떤 인터페이스를 구현하였는지, 그리고 클래스구조체에서 인터페이스구조체가 위치한 오프셋 등의 정보를 얻기 위해 필요하다.

인터페이스의 등록을 도20을 참조하여 하기에 설명한다.

도 20의 251 단계에서 정적초기화부(20)는 부모인터페이스가 존재하는지 검사한다. 해당 클래스가 부모인터페이스를 가지고 있으면, 즉, 해당 클래스가 최상위클래스가 아니면 252 단계로 진행하여 부모인터페이스의 등록을 위한 함수를 호출하여 상위의 모든 부모클래스에 대한 인터페이스 등록이 이루어지도록 한다. 모든 부모인터페이스에 관한 등록이 완료되면 253 단계로 진행하여 해당 클래스가 어떤 인터페이스를 구현하였는지, 그리고 클래스구조체에서 인터페이스구조체가 위치한 오프셋 등의 정보를 등록한다.

인터페이스의 등록이 완료되면 도 18a의 260 단계에서 정적초기화부(20)는 부모클래스의 재정의할 메소드가 존재할 경우 부모클래스의 메소드를 재정의 한다. 부모클래스의 메소드를 재정의 한 후에는 도 18b의 280 단계로 진행하며 해당 클래 스의 정적 멤버변수를 초기화한다.

이하, 동적초기화 동작을 도 19를 참조하여 하기에 상세히 설명한다.

동적초기화 과정은 사용자가 목적에 맞는 클래스를 사용하고자 할 때 해당 클래스를 인스턴스화 시키는 시점에 수행되며 클래스구조체를 초기화는 과정이다.

도19의 610 단계에서 인스턴스생성자(31, 32, 33, ...)는 해당 클래스가 최상위 클래스인지 검사한다. 해당 클래스가 최상위 클래스가 아니면 620 단계로 진행하여 부모클래스의 동적초기화를 요구한다. 따라서, 해당 클래스에 관련된 모든 부모클래스에 관하여 동적초기화가 이루어지도록 한다.

630 및 640단계에서 인스턴스생성자(31, 32, 33, ...)는 부모클래스의 동적 초기화 과정을 마치면 해당 클래스가 구현한 인터페이스를 초기화한다.

인터페이스의 초기화 동작을 도21을 통해 설명하면 다음과 같다.

도21의 641 단계에서 인스턴스생성자(31, 32, 33, ...)는 상속한 부모인터페이스의 존재에 따라 부모인터페이스의 초기화를 요청하여 관련된 모든 부모인터페이스의 초기화를 요구한다. 따라서, 해당하는 모든 부모인터페이스의 초기화가 이루어지게 된다.

관련된 부모인터페이스의 초기화가 완료되면 643 단계에서 인스턴스생성자(31, 32, 33, ...)는 인터페이스가 제공하는 메소드참조변수의 값을 설정하고, 644 및 645 단계에서 인터페이스 멤버변수의 초기화를 수행한다.

도21에 따른 인터페이스의 초기화가 완료되면 도 19의 650 및 660 단계를 통해 클래스의 멤버변수를 초기화한다.

이상에서 살펴본 바와 같이 본 발명은 절차적인 프로그램언어인 C언어의 구조체를 이용하여 객체지향적인 프로그래밍을 수행할 수 있도록 함으로써, 높은 시스템 사양을 요구하지 않으면서 객체지향성을 가지는 프로그래밍을 수행할 수 있는 장점이 있다.

Claims (24)

1. 객체 지향성 프로그래밍 구현을 위한 구조체가 저장되는 메모리에 있어서,

   상기 구조체는 클래스구조체 또는 클래스정보구조체로 이루어지며,

   상기 클래스구조체와 클래스정보구조체를 구비하는 클래스는

   상기 클래스정보구조체를 참조하는 멤버변수를 포함하는 최상위클래스구조체;

   상기 클래스가 구현한 인터페이스 정보를 포함하는 최상위클래스정보구조체;

   하나의 부모클래스구조체를 상속하는 클래스구조체 및

   상속하는 상기 부모클래스구조체의 부모클래스정보구조체를 포함하는 클래스정보구조체를 포함하며, 상기 메모리에 저장되는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
2. 제 1항에 있어서,

   상기 클래스구조체는 적어도 하나의 멤버변수를 포함하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
3. 제 1항 또는 제 2항에 있어서,

   상기 클래스의 부모클래스는 상기 최상위클래스나 상기 클래스의 상위클래스로 이루어지며, 상기 클래스구조체는 상기 부모클래스구조체의 멤버변수를 상기 클래스구조체 내의 최상위에 포함하며,

   상기 클래스정보구조체는 상기 부모클래스정보구조체 변수를 상기 클래스정보구조체의 최상위에 포함하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
4. 제 1항 또는 제 2항에 있어서,

   상기 클래스정보구조체는

   적어도 하나의 정적멤버변수와 메소드포인터를 더 포함하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
5. 제 1항 또는 제 2항에 있어서,

   상기 클래스구조체는 적어도 하나의 인터페이스 메소드를 구비하는 인터페이스구조체를 포함하며,

   상기 인터페이스구조체는 상기 부모클래스구조체와 멤버변수 사이에 위치되도록 구현되는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
6. 제 5항에 있어서,

   상기 인터페이스구조체는

   적어도 하나의 부모인터페이스구조체를 최상위에 포함하는 구조로 형성되어 인터페이스를 상속하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
7. 제 5항에 있어서,

   상기 인터페이스구조체는

   적어도 하나의 인터페이스 멤버변수를 더 포함하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
8. 제 1항 또는 제 2항에 있어서,

   상기 클래스는

   정적 클래스 초기화를 위해서 정적 클래스정보구조체 변수와 정적 클래스 초기화 함수를 제공하도록 형성되는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
9. 제 1항 또는 제2항에 있어서,

   상기 클래스는

   동적 클래스 초기화를 위해서 동적 클래스 초기화 함수를 제공하도록 형성되는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
10. 제 5항에 있어서,

    상기 인터페이스는

    인터페이스 등록을 위한 인터페이스 등록함수와 인터페이스의 초기화를 위한 인터페이스 초기화 함수 중 적어도 어느 하나의 함수를 제공하도록 형성되는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 구조체가 저장된 메모리.
11. 삭제
12. 삭제
13. 사용자프로그램유닛, 상기 사용자프로그램유닛과 연동되는 정적초기화부 및 다수의 인스턴스 생성자, 스택영역과 힙영역을 포함하며 상기 정적초기화부와 인스턴스 생성자에 연동되는 램과 상기 정적초기화부와 인스턴스 생성자에 연동되는 롬을 포함하는 메모리를 구비하는 휴대용 정보단말기에서 상기 메모리에 저장되는 구조체를 이용한 객체지향성 프로그램 구현을 위한 방법에 있어서,

    상기 램에 클래스정보구조체를 생성하는 제1단계;

    상기 사용자프로그램유닛이 상기 정적초기화부에 상기 클래스정보구조체의 초기화를 요청하는 제2단계;

    상기 정적초기화부가 상기 클래스정보구조체를 초기화하는 제3단계;

    상기 사용자프로그램유닛이 상기 인스턴스 생성자에 소정 클래스구조체의 인스턴스를 요청하는 제4단계;

    상기 인스턴스 생성자가 상기 힙영역에 상기 클래스구조체를 할당하는 제5단계;

    상기 인스턴스 생성자가 상기 클래스구조체를 초기화하는 제6단계 및

    상기 인스턴스 생성자가 상기 클래스구조체의 포인터를 상기 사용자프로그램유닛으로 반환하는 제7단계를 포함하는 것을 특징으로 하는 객체지향성 프로그램 구현을 위한 방법.
14. 제 13항에 있어서,

    상기 제3단계는,

    초기화되는 상기 클래스정보구조체의 클래스가 최상위클래스인지를 확인하는 과정;

    상기 클래스가 최상위클래스이면 클래스타입을 추가하는 과정;

    상기 클래스가 최상위클래스가 아니면 상기 부모클래스의 정적클래스 초기화함수를 호출하여 초기화하고 클래스타입을 추가하는 과정;

    상기 클래스가 구현한 인터페이스를 포함하면 상기 인터페이스 등록을 위한 함수를 호출하여 상기 인터페이스의 등록을 수행하는 과정;

    상기 클래스가 재정의할 메소드를 포함하면 상기 메소드를 재정의하는 과정 및

    상기 클래스가 정적 멤버변수를 포함하면 상기 정적 멤버변수를 초기화하는 과정을 포함하여 이루어지는 것을 특징으로 하는 객체지향성 프로그램 구현을 위한 방법.
15. 제 14항에 있어서,

    상기 인터페이스 등록을 위한 함수는

    상기 인터페이스가 부모인터페이스를 포함하면 상기 부모인터페이스의 등록함수를 호출하며,

    상기 인터페이스의 타입과 옵셋을 상기 클래스정보구조체에 등록하는 것을 특징으로 하는 객체지향성 프로그램 구현을 위한 방법.
16. 제 13항에 있어서,

    상기 6단계는,

    상기 클래스가 최상위클래스인지를 확인하는 과정;

    상기 클래스가 최상위클래스가 아니면 부모클래스구조체의 동적클래스 초기화함수를 호출하여 부모클래스를 초기화하는 과정;

    상기 클래스가 구현한 인터페이스를 포함하면 상기 인터페이스를 초기화하는 과정 및

    상기 클래스가 멤버변수를 포함하면 상기 멤버변수를 초기화하는 과정을 포함하는 것을 특징으로 하는 객체지향성 프로그램 구현을 위한 방법.
17. 제 16항에 있어서,

    상기 인터페이스를 초기화하는 과정은

    상기 인터페이스가 상속한 부모인터페이스가 존재하면 상기 부모인터페이스의 초기화 함수를 호출하며,

    상기 인터페이스의 메소드 참조변수를 초기화하며,

    상기 인터페이스의 멤버변수가 존재하면 상기 인터페이스의 멤버변수를 초기화하는 것을 특징으로 하는 객체지향성 프로그램 구현을 위한 방법.
18. 제 13항에 있어서,

    상기 클래스구조체는 상속한 부모클래스구조체를 상기 클래스구조체의 최상위에 포함하며,

    상기 사용자프로그램유닛이 상기 클래스구조체의 멤버변수에 접근할 때 상기 클래스구조체 형식으로 형변환하여 접근하는 것을 특징으로 하는 객체지향성 프로그램 구현을 위한 방법.
19. 제 13항에 있어서,

    상기 클래스정보구조체에서 최상위에 위치하는 최상위클래스정보구조체는 상기 클래스구조체에 클래스정보구조체의 포인터를 가지는 멤버변수를 포함하며,

    상기 인스턴스 생성자는 최상위에 위치하는 클래스구조체 내의 클래스정보구조체의 포인터를 가지는 멤버변수를 상기 클래스정보구조체의 포인터로 치환하여 접근하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 방법.
20. 제 14항에 있어서,

    상기 클래스구조체는 구현한 인터페이스들의 인터페이스구조체를 부모클래스구조체 바로 아래에 차례로 포함시키고,

    상기 사용자프로그램유닛이 상기 인터페이스구조체의 멤버변수에 접근할 때 상기 클래스구조체의 포인터에서 상기 인터페이스구조체의 오프셋을 더한 다음 상기 인터페이스구조체 타입으로 형변환하여 접근하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 방법.
21. 제 14항에 있어서,

    상기 클래스의 메소드 재정의는

    상기 부모클래스정보구조체에 클래스 메소드 포인터를 재정의 하고자 하는 함수의 포인터로 대체하는 것임을 특징으로 하는 구조체를 이용한 객체 지향성 프로그래밍 구현을 위한 방법.
22. 제 21항에 있어서,

    상기 클래스정보구조체는

    상기 클래스정보구조체의 메소드 재정의를 위하여 상기 클래스정보구조체에 재정의 할 수 있는 클래스 메소드 포인터를 선언하고,

    상기 클래스정보구조체에 선언되어 있는 클래스 메소드 포인터를 치환하는 함수를 포함하며,

    상기 클래스정보구조체에 선언되어 있는 클래스 메소드 포인터가 가리키는 실제 함수를 호출해주는 함수를 포함하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 방법.
23. 제 14항에 있어서,

    상기 인터페이스의 인터페이스구조체는 구현되어야 하는 인터페이스 메소드의 함수 포인터를 선언하며,

    상기 인터페이스구조체에 선언되어 있는 인터페이스 메소드 포인터를 치환하는 함수를 포함하며,

    상기 인터페이스구조체에 선언되어 있는 인터페이스 메소드 포인터가 가리키는 실제 함수를 호출해주는 함수를 포함하는 것을 특징으로 하는 객체 지향성 프로그래밍 구현을 위한 방법.
24. 제 23항에 있어서,

    상기 인터페이스 메소드의 구현은,

    상기 인터페이스의 인터페이스구조체에 있는 인터페이스 메소드 포인터를 구현하고자 하는 함수의 포인터로 대체하는 것임을 특징으로 하는 구조체를 이용한 객체 지향성 프로그래밍 구현을 위한 방법.

Images