tran_arraies = new transition_array*[max_prime_index];
for(int i = 0 ; i < max_prime_index ; i++) {
	tran_arraies[i] = new transition_array(prime_number[k]);
}

자바에 너무 익숙해져있어서 2차원 동적배열에서 디폴트생성자를 이용하지 않고 만드는 것에서 고생했다.

걍 객체에 포인터로 원하는 만큼 배열을 생성해놓고

반복문으로 돌아가면서 다시 원하는 만큼 배열을 생성하면 된다.

사실 위의 예제는 n*1의 배열인데, 런타임에 동적으로 배열을 임의의 크기로 생성하고 생성자도 원하는 값으로 넣어주기 위함이다.

void loadFile(char *path, vector  &node) {
	...
}

#pragma once 는 C의 헤더 파일 최상단에서 자주 볼 수 있는데, 컴파일러에게 해당 헤더 파일이 한번만

빌드되도록 알려주는 명령이다. 즉, 여러번 인클루드 되는 것을 컴파일러 차원에서 막아주게 된다.

예를 들어, A.h라는 파일이 여러 곳에서 복잡하게 #include 되어 쓰이게 된다면 그때마다 가각 정의가

추가되게 되어 중첩되는 경우가 생긴다. 이 경우 중복 정의되었다는 에러가 발생하게 된다.

즉, 같은 내용이 여러번 빌드되게 되는 것을 막기위해 #pragma once 를 사용하는 것이다.

int bin(int n, int k)
{
	int **B;
	B = new int*[n+1];
	for(int i=0 ; i<=n ; i++)
	{
		B[i] = new int[k+1];
	}

	for(int i=0 ; i<=n ; i++) 
	{
		for (int j=0 ; j<= i ; j++)
		{
			if(j==0 || j==i) 
			{
				B[i][j]=1;
			}
			else
			{
				B[i][j]=B[i-1][j-1] + B[i-1][j];
			}
		}
	}
	return B[n][k];
}

int partition(int theList[], int start, int end)
{	int pivot = theList[end];                                       
    int bottom = start-1;                                                   
    int top = end;                                                           
    bool notdone = true;
    while (notdone)
	{
        while (notdone)
	{
            bottom += 1;                  
            if (bottom == top)   
	    {
                notdone = false;                        
                break;
	    }
            if (theList[bottom] > pivot)   
	     {
                theList[top] = theList[bottom];       
                break;
	     }
	}  
	while (notdone)
	{
            top = top-1;                      
            
            if (top == bottom) 
	    {
                notdone = false;                      
                break;
	     }
            if (theList[top] < pivot)
	    {   
                theList[bottom] = theList[top];
		break;
	     }      
	}
    }
    theList[top] = pivot;                          
    return top;
}//Actual function call within program
int quickSort(int theList[], int start, int end)
{	if (start < end)     
	{
             int split = partition(theList, start, end);   //recursion   
             quickSort(theList, start, split-1);         
             quickSort(theList, split+1, end); 
	}
        else
	{
             return 0;
	}
}