기억창고

#include <iostream>
using namespace std;

static const int fix_factor = 4096; // 2의 12승
static const int fix_shift = 12; // 쉬프트 값

int main()
{
 // 부동 -> 고정
 double a = 3.245;
 int fix_a = (int)(a*fix_factor);

 // 정수 -> 고정소수
 int b = 10;
 int fix_b = b << fix_shift;

 // 고정소수 -> 부동소수
 double c = (double)fix_a / fix_factor;

 // 고정소수 -> 정수로
 int d = fix_b >> fix_shift;

 printf(" a(3.245) = %d(0x%8X)\n b(10) = %d(0x%8X)\n c(double) = %f(0x%8X)\n d(고정소수를 정수변환) = %d(0x%8X)\n",a,a,b,b,c,c,d,d);

 // 덧셈, 뺄셈
 int plus = fix_a + fix_b;
 int minus = fix_a - fix_b;

 // 곱셈
 int multi = (fix_a * fix_b) >> fix_shift;

 // 나눗셈
 int div = (fix_a << fix_shift) / fix_b;

 printf("\n고정소수점 %d(%0.3f)와 %d(%d)끼리의 연산\n", fix_a, a, fix_b, b);
 printf("+ : %d, - : %d, * : %d, / : %d\n", plus, minus, multi, div);

 printf("fix_factor 만큼 나누기\n");
 printf("+ : %d, - : %d, * : %d, / : %d\n",
  plus / fix_factor , minus / fix_factor, multi / fix_factor, div / fix_factor);

 printf("fix_shiht 만큼 밀기\n");
 printf("+ : %d, - : %d, * : %d, / : %d\n",
  plus >> fix_shift , minus >> fix_shift, multi >> fix_shift, div >> fix_shift);
}

그러니까 32비트열에
xxxxxxxxxxxx.oooooooooooooooooooo
과 같이 임의 의 소수점을 찍어서 거기에 숫자 넣어서 처음부터 계산하는게 아니고

float 나 double 값을 곱셈해서 쉬프트를 시킨후 계산만 정수 연산부를 사용하는 것임.
대부분 cpu는... 정수 연산이 부동 소수점 연산보다 빠르니.. 이게 좋을꺼 같다.

만약, 아예 비트를 쪼개서 정수부, 소수부로 나누어서 계산하고 싶다면..
typedef unsigned int fint;
typedef unsigned char u8;
typedef unsigned short u16;

#define make_fint(i,f)  (fint)(f | i << 20)   // int를 부동소수점 마냥 쓰기
#define get_int(i)   (fint)(i >> 20)    // 정수부분 가져오기
#define get_float(f)  (fint)((f << 12) >> 12)  // 소수점 아래 부분 가져오기
#define get_upper(a)  (fint)(a >> 20)    // 소수점끼리 연산으로 정수로 올라온 숫자 가져오기

이렇게 하고.. 각각 연산에 적당한 함수를 만들어준뒤, 그 함수를 통해서 연산을 해야 할것이다.
이건.. 좀 빡센듯;;

#include <iostream>

using namespace std;

typedef unsigned int fint;
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;

#define make_fint(i,f)  (fint)(f | i << 20)   // int를 부동소수점 마냥 쓰기
#define get_int(i)   (fint)(i >> 20)    // 정수부분 가져오기
#define get_float(f)  (fint)((f << 12) >> 12)  // 소수점 아래 부분 가져오기
#define get_upper(a)  (fint)(a >> 20)    // 소수점끼리 연산으로 정수로 올라온 숫자 가져오기

fint fint_plus(fint a, fint b)
{
 int ai, af;
 int bi, bf;
 int upper;
 int ri, rf;

 ai = get_int(a);
 af = get_float(a);

 bi = get_int(b);
 bf = get_float(b);

 rf = af + bf;
 upper = get_upper(rf);
 ri = ai + bi + upper;
 
 return make_fint(ri,rf);
}

fint fint_sub(fint a, fint b)
{
 int ai, af;
 int bi, bf;
 int upper;
 int ri, rf;

 ai = get_int(a) - 1;
 af = get_float(a);

 bi = get_int(b);
 bf = get_float(b);

 rf = (af + (1<<21)) - bf;
 upper = get_upper(rf);
 ri = (ai + upper) - bi;
 
 return make_fint(ri,rf);
}

int main()
{
 int a = 0xff0;
 int b = 0xf5ff0;
 fint c = make_fint(a,b);
 
 printf("%x\n", c);

 fint d = get_int(c);
 fint e = get_float(c);
 printf("int : %x,    float : %x\n", d, e);
 
 fint f,g;
 f = make_fint(5,5000);
 g = make_fint(4,9920);

 fint sum = fint_plus(f,g);
 fint sub = fint_sub(f,g);
 printf("a = %d.%d,   b = %d.%d\n",
  get_int(f), get_float(f), get_int(g),get_float(g));
 printf("plus %d.%d, sub %d.%d\n",
  get_int(sum), get_float(sum), get_int(sub),get_float(sub));
/*
 5.005
 -4.992
 --------
    008 + 005
 013

  5.992
 -6.001
 ---------
 -1.991
 */
}

// 하루히 와핑 소스
/*
// 바꾼 이미지 복구? 음.. 제거쪽이 해석이 맞을지도
//v3.0
function MM_swapImgRestore()
{
 var i,x,a=document.MM_sr;
 for(i=0; a && i<a.length&&(x=a[i]) && x.oSrc;i++)
  x.src=x.oSrc;
}

// 이미지들을 먼저 읽어오기
//v3.0
function MM_preloadImages()
{
 var d=document;
 
 if(d.images)
 {
  if(!d.MM_p)
   d.MM_p = new Array();

  var i, j = d.MM_p.length, a=MM_preloadImages.arguments;
  for(i=0; i < a.length; i++)
   if (a[i].indexOf("#") != 0)
   {
    d.MM_p[j]=new Image;
    d.MM_p[j++].src=a[i];
   }
 }
}

// 오브젝트 찾기 (즉 케릭터가 주목하는 방향 좌표)
//v4.01
function MM_findObj(n, d)
{
 var p,i,x; 

 if(!d)
  d=document;

 if((p=n.indexOf("?")) > 0 && parent.frames.length)
 {
  d=parent.frames[n.substring(p+1)].document;
  n=n.substring(0,p);
 }

 if(!(x=d[n]) && d.all)
  x=d.all[n];

 for (i=0; !x && i<d.forms.length; i++)
  x=d.forms[i][n];

 for(i=0; !x && d.layers && i<d.layers.length; i++)
  x=MM_findObj(n,d.layers[i].document);

 if(!x && d.getElementById)
  x=d.getElementById(n);
 return x;
}

// 이미지 바꾸기
//v3.0
function MM_swapImage()
{
 var i, j=0, x, a=MM_swapImage.arguments;

 document.MM_sr = new Array;

 for(i=0; i < (a.length-2); i+=3)
  if ((x = MM_findObj(a[i])) !=null)
  {
   document.MM_sr[j++]=x;

   if(!x.oSrc)
    x.oSrc=x.src;

   x.src=a[i+2];
  }
}
*/

최근 하고 있는 것이 여러 뻘짓이다 보니 본이 아니게 3중 포인터를 쓰게 되더군요.

대략… 3차원 표현 이라던가…

2차원의 영역중, 각 픽셀의 갖고있는 간단한 값을 가져올 때, 안쓸꺼 같던것들이 자주 쓰이더군요.

일단 예제.. 여기서 예제는 int a[10][20][30] 과 같은 역활을 하는 동적 메모리 할당을 해봅니다.

일단 C언어부터…

// 만들때

int ***ptr;
ptr = (int ***)malloc(sizeof(int **) * 10);

for(i=0; i < 10; ++i)
{
    ptr[i] = (int **)malloc(sizeof(int *) * 20);   

    for(j=0; j < 20; ++j)
        ptr[i][j] = (int *)malloc(sizeof(int) * 30);
}

// 해제할때
for(i=0; i < 10; ++i)
{
    for(j=0; j < 20; ++j)
        free(ptr[i][j]);

    free(ptr[i]);
}

free(ptr);

그리고 C++, C++ 답게 new와 delete 명령어를 써서 (물론 위의 C방법으로 해도 상관없습니다.)

 마지막으로 Java ...
Java의 경우.. 포인터가 없죠;;
Java의 메모리는 C언어처럼 직접 건들이는 구조가 아니고,
물리적 메모리 공간과 별도로 여길 관리하는 메모리 관리자가 있습니다..(Virtual Machine(이하 VM)안에)
여기의 메모리 관리자가 알아서 할당합니다. (OS에서 자원 관리 하듯이라 생각하셔도 됩니다.)

즉 int a[10] 이라 하면, 내부적으로는 C언어처럼 malloc(sizeof(int) * 10)이 일어난다는거죠.
C언어적인 문법상으로 보면 그냥 정적 배열처럼 보이지만... 내부적으론 동적 배열 처리한다고 보시면 됩니다.

해제는.. 간단하게 null 해주면 VM의 메모리 관리자가 해당 영역을 없는 셈 칩니다.
(파일을 지울때 앞글자만 지워주고 없는셈 치는것과 같은 이치입니다)

완전히 메모리 상에서 지우고 싶을땐 가비지 컬렉터를 강제로 실행시켜줘야 하지만..
굳이 할필요는 없습니다.
만약 VM이 메모리 할당이 일어날때 더 이상 메모리가 없다면,
현재 사용되지 않는 메모리 할당자들,
즉 위의 null 처럼 되어있는것.. 이라던가, 클래스에서 나와 더이상 사용하지 않는 변수들 같은것들을
찾아 지워준뒤, Compaction등이 일어납니다. 그리고 빈곳에 메모리를 할당하죠.
개념은 이정도고 실제 작동원리나 자세한건 Java책을 참고하시기 바랍니다.

// 만들때
int ptr[][][] = null;
ptr = new int[10][20][30];

// 해제할때
ptr = null;
System.gc(); // 선택사항

전세계에서 제일 많이 사용하는 언어는 자바란 이유가.. 이런 편리함 때문일껍니다... T_T

C언어의 모토(motto)는
-> 어떤 머신이든 제어하는 언어를 만들자.
이지만,

Java의 모토(motto)는
-> 코딩은 1번, 코딩된 소스를 변형없이 모든 머신에서 돌아가는 프로그램을 만들자
라고 합니다.

실제... C언어는 ARM 계열이나. 리눅스의 GCC, MS의 Visual C++ ... 미묘하게 다릅니다.
int 의 경우만해도 보통은 4byte로 알고있지만, 사실은 해당 머신에서 숫자를 표현하기 적당한 공간을 뜻합니다.
무슨말이냐면
간단한 휴대폰의 경우 int의 할당은 2byte or 1byte 만 할당될수도 있고, PC에선 4byte, 서버나 과학용 컴퓨터에선 8byte 이상을 할당할수 있다는 얘기죠.
그게 무슨 대수냐..... 하실지도 모르지만.. 게임 만들다보면.. 이것까지 제어하는 부분까지.. orz

Java는.. int 는 4byte 라고 정해져 있습니다. 이건 어떤 머신이든 VM이 있다면 무족건 4byte로 쳐줍니다.