class
 MyObject
 {

public
:

     MyObject
()
 {
 }


     int
 getData
();
  // 隱匿된 데이터는 메서드를 使用하여 인터페이스로 쓸 수 있다.


private
:
 // 이 指定者는 自己 클래스에서만 액세스를 限定한다. 隱匿하는 方法으로 使用.

     int
 m_data
;

};


int
 MyObject::getData
()

{

   return
 this
->
m_data
;
 // this가 自動으로 넘어온다.

}

#include
 <iostream>


typedef
 struct
 MsgBuff
 {

    MsgBuff
 *
link
;

    int
  szpkg
;

    int
  szdata
;

    void
 *
data
;

}
 MsgBuff
;


class
 A
 {

public
:

    A
()
 {
 num
 =
 0
;
 }

    int
 num
;

};


char
 gbuff
[
1024
];


int
 main
(
int
 argc
,
 char
*
 argv
[])

{

    MsgBuff
 *
pmsg
 =
 (
MsgBuff
*
)
 gbuff
;

    int
 szpkg
 =
 sizeof
(
A
)
+
sizeof
(
pmsg
->
link
)
+
sizeof
(
int
)
*
2
;

    pmsg
->
link
 =
 NULL
;

    pmsg
->
szdata
 =
 sizeof
(
A
);

    pmsg
->
szpkg
 =
 szpkg
;


    A
 *
pa
 =
 (
A
*
)
 &
pmsg
->
data
;

    pa
->
num
 =
 10
;

    std
::
cout
 <<
 pa
->
num
 <<
 std
::
endl
;


    return
 0
;

}

#include
 <iostream>

using
 namespace
 std
;


class
 A
 {

public
:

   A
()
 {
 num
 =
 0
;
 }

   A
(
int
 n
)
 :
 num
(
n
)
 {
 cout
 <<
 "生聖子 呼出 : "
 <<
 this
 <<
 endl
;
  }

   ~
A
()
 {
 cout
<<
 "消滅子 呼出 : "
 <<
 this
 <<
 endl
;
 }

   int
 getNum
()
 {
 return
 num
;
 }


private
:

   int
 num
;

};


int
 main
()

{

   int
 num
;


   cout
 <<
 "블럭 始作 합니다."
 <<
 endl
;

   {
  // 블럭 始作하면 只今부터 宣言되는 變數나 클래스는 블럭이 끝나면 사라진다.

      A
 a
(
10
);


      num
 =
 a
.
getNum
();

      cout
 <<
 "블럭 안에서 a.getNum() = "
 <<
 a
.
getNum
()
 <<
 endl
;


   }
 // 블럭이 끝나면 客體 a는 消滅됨. 消滅自家 呼出된다.

   cout
 <<
 "블럭 끝났습니다. num = "
 <<
 num
 <<
 endl
;

   return
 0
;

}

/// 파일 : MyObject.h ////////////////////////////////////


class
 MyObject
 {
 // 클래스의 始作

public
:

   MyObject
();
   // 生聖子1

   MyObject
(
int
 age
,
 char
 *
name
);
  // 生聖子2 : 生聖子는 여러가지가 可能하다.

   virtual
 ~
MyObject
();
  // 消滅子


   // 멤버變數 age, name, fdyn가 privated이므로 다른 客體에서 接近이 不可能 하다.

   // 따라서 멤버函數로 解決한다. setAge, getAge,setName,getName


   void
 setAge
(
int
 age
)
 {
 this
->
age
 =
 age
;
 }
  // 函數 本體를 클래스 內에 코딩할 수 있다.

                    // 모든 函數를 헤더의 클래스 안에 코딩하면 클래스 全體를 把握하는데 不便할 수 있다.

                    // 그리고 파일을 cpp와 h로 나누는 意味가 毁損될 수 있다.

   int
 getAge
()
 {
 return
 age
;
 }


   void
 setName
(
char
 *
n
,
 int
 opt
 =
 0
);
  // 萬若 opt을 使用하지 呼出하면 自動으로 0을 設定한다.

   char
*
 getName
();


   static
 int
 counter
;


private
:

   int
 age
;

   char
 *
name
;

   int
  fdynm
;
  // name 變數의 메모리 空間을 new (malloc())로 만들었는지를 설정

};


/// 파일 : MyObject.cpp //////////////////////////////////

#include
 <iostream>

#include
 "MyObject.h"

using
 namespace
 std
;


MyObject
::
MyObject
()
 // 生聖子1

{

   age
 =
 0
;

   name
 =
 NULL
;

   fdynm
 =
 0
;


   cout
 <<
 "+生聖子1 MyObject() : "
 <<
 this
 <<
 endl
;

}


MyObject
::
MyObject
(
int
 age
,
 char
 *
name
)
 // 生聖子2

{

   this
->
age
 =
 age
;

   this
->
name
 =
 name
;


   cout
 <<
 "+生聖子2 MyObject("
<<
 age

 <<
","
<<
 name
 <<
 ") : "
 <<
 this
 <<
 endl
;

}


MyObject
::~
MyObject
()
 // 消滅子

{

	cout
 <<
 "-消滅子 MyObject("
<<
 name
 <<
") : "
 <<
 this
 <<
 endl
;


	if
 (
fdynm
)
 {
 // name을 貯藏할 空間을 new로 만들었다면 削除 한다.

		cout
 <<
 " delete name = "
 <<
 name
 <<
 endl
;

		delete
 []
 name
;

		name
 =
 NULL
;

	}

}


int
 MyObject
::
counter
 =
 0
;
 // static은 各 客體마다 貯藏空間이 確保 되지 않는다.

                            // 全體에서 單 하나의 變數 空間 만이 存在한다.

                            // public이므로 어디에서나 接近이 可能하다.


char
*
 MyObject::getName
()
 {
 return
 name
;
 }


void
 MyObject::setName
(
char
 *
n
,
 int
 opt
)

{

	if
 (
fdynm
)
 delete
 []
 name
;

	name
 =
 n
;

	fdynm
 =
 opt
;

}


/// 파일 : main.cpp //////////////////////////////////

#include
 <iostream>

#include
 "MyObject.h"

using
 namespace
 std
;


//// 全域變數 //////////////////


MyObject
 gMe
(
19
,
 "洪吉童"
);
 // 客體를 生成하고, 生聖子2을 呼出 한다.


int
 main
(
int
 argc
,
 char
*
 argv
[])

{

	cout
 <<
 "main() 始作.
\n
"
;


	MyObject
 *
pm
 =
 &
gMe
;


	MyObject
::
counter
++
;

	cout
 <<
 MyObject
::
counter
 <<
 " "
 <<
 pm
->
getName
()
 <<
 " / "

 <<
 pm
->
getAge
()
 <<
 endl
;


	MyObject
 kim
;
 // 客體를 生成하고, 生聖子1을 呼出 한다.

	pm
 =
 &
kim
;

	char
 *
pname
 =
 new
 char
[
50
];

	strcpy
(
pname
,
 "李舜臣"
);

	pm
->
setName
(
pname
,
 1
);

	pm
->
setAge
(
33
);


	pm
->
counter
++
;

	cout
 <<
 MyObject
::
counter
 <<
 " "
 <<
 pm
->
getName
()
 <<
 " / "

 <<
 pm
->
getAge
()
 <<
 endl
;


	pm
 =
 new
 MyObject
();
 // 客體를 動的으로 만든다. 生聖子1 使用.

	pm
->
setName
(
"世宗大王"
);

	pm
->
setAge
(
33
);


	MyObject
::
counter
++
;

	cout
 <<
 MyObject
::
counter
 <<
 " "
 <<
 pm
->
getName
()
 <<
 " / "

 <<
 pm
->
getAge
()
 <<
 endl
;

	delete
 pm
;


	cout
 <<
 "main() 끝.
\n
"
;


	return
 0
;

}

</
source
 >

實行結果
 예
:

 +
生聖子2
 MyObject
(
19
,
洪吉童
)
 :
 00F
DD174

 main
()
 始作
.

 1
 洪吉童
 /
 19

 +
生聖子1
 MyObject
()
 :
 0031F
9
C4

 2
 李舜臣
 /
 33

 +
生聖子1
 MyObject
()
 :
 004
D4948

 3
 世宗大王
 /
 33

 -
消滅子
 MyObject
(
世宗大王
)
 :
 004
D4948

 main
()
 끝
.

 -
消滅子
 MyObject
(
李舜臣
)
 :
 0031F
9
C4

    delete
 name
 =
 李舜臣

 -
消滅子
 MyObject
(
洪吉童
)
 :
 00F
DD174


===
 客體의
 메모리
 救助
 ===


客體는
 클래스에
 依해
 規定된
 救助에
 따라
 메모리
 空間을
 確保하고
 메모리에
 [[
액세스
 (
마이크로프로세서
)
|
액세스
]]
 함으로써
 데이터
 處理가
 된다
.
 이
 救助는
 基本的으로
 struct와
 別로
 다를
 바가
 없다
.
 멤버變數만을
 모아
 順序대로
 羅列하여
 特定
 크기의
 메모리를
 確保하면
 된다
.
 struct에
 C
++
에
 必要한
 몇가지
 追加될
 수
 있다
.


위의
 예
 프로그램의
 客體構造를
 알기
 爲해
 다음과
 같이
 프로그램
 하면
:


<
syntaxhighlight
 lang
=
"cpp"
>

#include
 <iostream>

#include
 <stdio.h>

#include
 "MyObject.h"

using
 namespace
 std
;


MyObject
 hong
(
19
,
 "洪吉童"
);


int
 main
(
int
 argc
,
 char
*
 argv
[])

{

	MyObject
 *
pm
 =
 &
hong
;


	printf
(
"sizeof(MyObject)=%d
\n
"
,
 sizeof
(
MyObject
)
 );

	printf
(
"&pm=0x%08X, sizeof(pm)=%d
\n
"
,
 &
pm
,
 sizeof
(
pm
)
 );

	printf
(
"pm=0x%08X
\n
"
,
 pm
 );


	printf
(
"&hong=0x%08X, sizeof(hong)=%d
\n
"
,
 &
hong
,
 sizeof
(
hong
)
 );

	printf
(
"&counter=0x%08X, value=%d
\n
"
,
 &
MyObject
::
counter
,
 MyObject
::
counter
);

	printf
(
"&age=0x%08X, value=%d
\n
"
,
 &
hong
.
age
,
 hong
.
age
 );

	printf
(
"&name=0x%08X, value=%s
\n
"
,
 &
hong
.
name
,
 hong
.
name
 );

	printf
(
"&fdynm=0x%08X, value=%d
\n
"
,
 &
hong
.
fdynm
,
 hong
.
fdynm
 );


	MyObject
 lee
(
23
,
 "李舜臣"
);

	printf
(
"&lee=0x%08X
\n
"
,
 &
lee
);


        return
 0
;

}

/// 파일 : MyStruct.h ///

#ifndef MYSTRUCT_H

#define MYSTRUCT_H


typedef
 struct
 {

   static
 int
 counter
;


   int
 age
;

   char
 *
name
;

   int
  fdynm
;

}
 MyStruct
;


void
 setMyStruct
(
MyStruct
*
 pthis
,
 int
 age
,
 char
 *
name
,
 int
 opt
 =
 0
);


#endif


// 파일 : MyStruct.cpp /////////

#include
 <stdio.h>

#include
 "MyStruct.h"


int
 MyStruct
::
counter
 =
 0
;


void
 setMyStruct
(
MyStruct
*
 pthis
,
 int
 age
,
 char
 *
name
,
 int
 opt
)

{

   pthis
->
age
 =
 age
;

   pthis
->
name
 =
 name
;

   if
 (
pthis
->
fdynm
)
 delete
 []
 pthis
->
name
;

   pthis
->
fdynm
 =
 0
;

}


// 파일 : main.cpp ////////

#include
 <stdio.h>

#include
 "MyStruct.h"


int
 main
()

{

   MyStruct
 stdata
;

   stdata
.
fdynm
 =
 0
;

   setMyStruct
(
&
stdata
,
 11
,
 "Song"
);


   printf
(
"&stdata=0x%08X, sizeof(stdata)=%d
\n
"
,
 &
stdata
,
 sizeof
(
stdata
)
 );

   printf
(
"&counter=0x%08X, value=%d
\n
"
,
 &
MyStruct
::
counter
,
 MyStruct
::
counter
);

   printf
(
"&age=0x%08X, value=%d
\n
"
,
 &
stdata
.
age
,
 stdata
.
age
 );

   printf
(
"&name=0x%08X, value=%s
\n
"
,
 &
stdata
.
name
,
 stdata
.
name
 );

   printf
(
"&fdynm=0x%08X, value=%d
\n
"
,
 &
stdata
.
fdynm
,
 stdata
.
fdynm
 );

   // ...

}

#include
 <iostream>


class
 A
 {

public
:

   A
()
 {
 num
 =
 0
;
 }

   A
(
int
 n
)
 {
 num
 =
 n
;
 }


   int
 num
;

};


int
 main
(
int
 argc
,
 char
*
 argv
[])

{

    A
 a
(
10
);

    char
 buff
[
4
];

    char
 *
pstr
 =
 buff
;


    std
::
cout
 <<
 "num="
 <<
 a
.
num
 <<
 std
::
endl
;

    printf
(
"&a=0x%08X
\n
"
,
 &
a
);

    printf
(
"buff=0x%08X
\n
"
,
 buff
);


    for
 (
int
 cnt
 =
 0
;
cnt
 <
 16
;
cnt
++
)

	*
pstr
++
 =
 cnt
;


    std
::
cout
 <<
 "num="
 <<
  a
.
num
 <<
 std
::
endl
;


    return
 0
;

}

struct
 MyStruct
 {

   int
 opt
;

   int
 age
;

   char
 *
name
;

};


class
 MyObject

{

public
:

   MyObject
()
 {
 opt
 =
 age
 =
 0
;
 name
 =
 NULL
;}

   void
 MyObject
::
setMyObject
(
int
 age
,
 char
 *
name
,
 int
 opt
 =
 0
);


private
:

   int
 opt
;

   int
 age
;

   char
 *
name
;

};


void
 setMyStruct
(
MyStruct
*
 pthis
,
 int
 age
,
 char
 *
name
,
 int
 opt
/* = 0*/
)

{

   pthis
->
opt
 =
 opt
;

   pthis
->
age
 =
 age
;

   pthis
->
name
 =
 name
;

}


void
 MyObject::setMyObject
(
int
 age
,
 char
 *
name
,
 int
 opt
/* = 0*/
)

{

   this
->
opt
 =
 opt
;

   this
->
age
 =
 age
;

   this
->
name
 =
 name
;

}

class
 A
 {

public
:

   A
(
int
 n
)
 {
 num
 =
 n
;
 }

   int
 num
;

   int
 add
(
int
 n2
)
 {
 return
 (
num
 +=
 n2
);
 }


   static
 int
 add
(
A
 *
pa
,
 int
 n2
);

};


int
 A::add
(
A
 *
pa
,
 int
 n2
)

{

    //num += n2;  // 誤謬 : this을 使用할 수 없다. 客體의 포인터가 넘어오지 않는다.

 // error C2597: illegal reference to non-static member 'A::num'

    pa
->
num
 +=
 n2
;

    return
 pa
->
num
;

}


int
 main
()

{

    A
 a
(
10
);

    int
 r
 =
 A
::
add
(
&
a
,
 20
);
     // 結果 30

    std
::
cout
 <<
 r
 <<
 std
::
endl
;


    r
 =
 a
.
add
(
&
a
,
 10
);
           // 結果 40

    std
::
cout
 <<
 r
 <<
 std
::
endl
;


    return
 0
;

}