ATL / WTL / STL

<pre>#include <stdio.h>

int main()
{
	int i, num[10];
	int *p;
	p = &num[0];
	
	for(i=0; i<=10; i++)
	{
		(p+i) = i;
		printf("\n%d", *(p+i));
	}
	
	
	return 0;
}

#include <stdio.h>

int final_array(int arr[], int size, int k, int i);
void array(int arr[], int i, int size);

int main()
{
	int num, size[100];
	int i, j, k=0;
	int arr[100][100];

	printf("Enter the number of arrays: \t");
	scanf("%d", &num);
	num = num < 100 ? num: 100;
	//feeding elements.
	for (i = 0; i<num; i++)
	{
		printf("\nEnter the size of the array: \t");
		scanf("%d", &size[i]);

		printf("\nEnter the array: ");
		//int arr[i][size[i+1]];
		size[i] = size[i] < 100 ? size[i] : 100;
		array(&arr[i][0], i, size[i]);
	}

	for(i=0; i<num; i++)
    {
        final_array(&arr[i][0], size[i], k, i);
        printf("\n");
    }

	printf("\nPress Enter key to exit.\n");
	getchar();

	return 0;
}

void array(int arr[], int i, int size)
{
	int j;
	for (j = 0; j<size; j++)
	{
		printf("\nEnter arr[%d][%d]: \t",i, j);
		scanf("%d", &arr[j]);
	}
}

int final_array(int arr[], int size, int k, int i)
{
    if(k<=size)
    {
        printf("%d", arr[k]);
        final_array(&arr[i][0], size[i], k++, i);
    }
    else
        return 0;


    /*
    int j;
    for(j=0; j<size; j++)
    {
    	printf("%d\t", arr[j]);
	}
	*/
}

<pre>
#include <stdio.h>

int i, j;
int arr[100][100];

void array(int arr[i][j], int size[i+1])
{

	for(j=0; j<size[i+1]; j++)
	{
		scanf("%d", &arr[i][j]);
		printf("arr[%d][%d]\n", i, j);
	}
	
}

/*
void merge()
{
	int ;

}
*/

int main()
{
	int num,size[100];

	printf("Enter the number of arrays: \t");
	scanf("%d", &num);
	
	size[0] = 0;
	
	//feeding elements.
	for(i=0; i<num; i++)
	{
		printf("\nEnter the size of the array: \t");
		scanf("%d", &size[i+1]);

		printf("\nEnter the array: \n");
		//int arr[i][size[i+1]];
		array(arr, size);
	}

	for(i=0; i<num; i++)
	{
		for(j=0; j<size[i+1]; j++)
		{
			printf("\n%d", arr[i][j]);
		}
	}
	
	return 0;
}

#include <stdlib.h>

#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/glut.h>
#endif

// all variables initialized to 1.0, meaning
// the triangle will initially be white
float red=1.0f, blue=1.0f, white=1.0f;

// angle for rotating triangle
float angle = 0.0f;

void changeSize(int w, int h) {

	// Prevent a divide by zero, when window is too short
	// (you cant make a window of zero width).
	if (h == 0)
		h = 1;
	float ratio =  w * 1.0 / h;

        // Use the Projection Matrix
	glMatrixMode(GL_PROJECTION);

        // Reset Matrix
	glLoadIdentity();

	// Set the viewport to be the entire window
	glViewport(0, 0, w, h);

	// Set the correct perspective.
	gluPerspective(45.0f, ratio, 0.1f, 100.0f);

	// Get Back to the Modelview
	glMatrixMode(GL_MODELVIEW);
}

void renderScene(void) {

	// Clear Color and Depth Buffers
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// Reset transformations
	glLoadIdentity();

	// Set the camera
	gluLookAt(	0.0f, 0.0f, 10.0f, 0.0f, 0.0f,  0.0f, 0.0f, 1.0f,  0.0f);

	glRotatef(angle, 1.0f, 1.0f, 0.0f);

	glColor3f(red,white,blue);
	glBegin(GL_TRIANGLES);
	  //glColor3f(1.0, 1.0, 1.0);     // Red
      glVertex3f( 0.0f, 1.0f, 0.0f);
     // glColor3f(1.0, 1.0, 1.0);    // Green
      glVertex3f(-1.0f, -1.0f, 1.0f);
      //glColor3f(1.0, 1.0, 1.0);     // Blue
      glVertex3f(1.0f, -1.0f, 1.0f);
 
      // Right
     // glColor3f(0.0, 1.0, 1.0);     // Red
      glVertex3f(0.0f, 1.0f, 0.0f);
      //glColor3f(0.0, 1.0, 1.0);   // Blue
      glVertex3f(1.0f, -1.0f, 1.0f);
      //glColor3f(0.0, 1.0, 1.0);    // Green
      glVertex3f(1.0f, -1.0f, -1.0f);
 
      // Back
      //glColor3f(0.0, 0.5, 0.0);    // Red
      glVertex3f(0.0f, 1.0f, 0.0f);
    // glColor3f(0.0, 0.5, 0.0);    // Green
      glVertex3f(1.0f, -1.0f, -1.0f);
    // glColor3f(0.0, 0.5, 0.0);     // Blue
      glVertex3f(-1.0f, -1.0f, -1.0f);
 
      // Left
    // glColor3f(0.6, 0.6, 0.6);       // Red
      glVertex3f( 0.0f, 1.0f, 0.0f);
     // glColor3f(0.663, 0.663, 0.663);      // Blue
      glVertex3f(-1.0f,-1.0f,-1.0f);
    // glColor3f(0.663, 0.663, 0.663);      // Green
      glVertex3f(-1.0f,-1.0f, 1.0f);

	glEnd();

	angle+=0.1f;

	glutSwapBuffers();
}

void processNormalKeys(unsigned char key, int x, int y) {

	if (key == 27)
		exit(0);
}

void processSpecialKeys(int key, int x, int y) {

	switch(key) {

			if(key=='1')
	{
		angle+=10;
	}
	if(key=='0')
	{
		angle+=1;
	}

		case GLUT_KEY_F1 :
				red = 1.0;
				white = 0.0;
				blue = 0.0;
				; break;
		case GLUT_KEY_F2 :
				red = 0.0;
				white = 1.0;
				blue = 0.0; break;
		case GLUT_KEY_F3 :
				red = 0.0;
				white = 0.0;
				blue = 1.0; break;
	}
}

int main(int argc, char **argv) {

	// init GLUT and create window
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
	glutInitWindowPosition(100,100);
	glutInitWindowSize(640,480);
	glutCreateWindow("Lighthouse3D- GLUT Tutorial");

	// register callbacks
	glutDisplayFunc(renderScene);
	glutReshapeFunc(changeSize);
	glutIdleFunc(renderScene);

	// here are the new entries
	glutKeyboardFunc(processNormalKeys);
	glutSpecialFunc(processSpecialKeys);

	// enter GLUT event processing cycle
	glutMainLoop();

	return 1;
}