C / C++ / MFC

typedef struct
{
  int nID;
  TCHAR szName[MAX_PATH];
}MyStruct1;

//I declare a list of MyStruct1 object with a key of type TCHAR as below.
typedef std::map<std:basic_string xmlns:std="#unknown"><tchar>, MyStruct1> MyStructList;</tchar></std:basic_string>

typedef struct
{
 int age;
 TCHAR Place[MAX_PATH];
 MyStructList ObjList;
}MyMainStruct;

void MyApp::main()
{
 MyMainStruct objMainStruct;
 UpdateList( objMainStruct.ObjList);
}

//The list is being updated in this function below.
void MyApp::UpdateList(MyStructList &ObjList)
{
  MyStruct1 MyStructObj;
  _tcscpy(MyStructObj.szName, _T("ABCDE"));
   MyStructObj.nID = 2532;
   ObjList.Insert(MyStructList::value_type(_T("First"), MyStructObj)).second;
  //fill this list with multiple MyStruct1 object and unique keys.
}

<br />
     button1.Create( TEXT( "xxx" ),<br />
		WS_VISIBLE|WS_CHILD|WS_GROUP|BS_AUTORADIOBUTTON,<br />
			CRect( 250, 50+charHeight+6, 250 + 9*charWidth, 50+2*(charHeight+6)), this, 2500 );<br />
<br />
<br />
	button2.Create( TEXT( "yyyyyy" ),<br />
		WS_VISIBLE|WS_CHILD|BS_AUTORADIOBUTTON,<br />
			CRect( 250, 50+2*(charHeight+6), 250 + 9*charWidth, 50+3*(charHeight+6)), this, 2500 );<br />

-----------------------------------------------------------------
pComboBox[i]->AddString(str);  //line 1 
int iCurIndex = pComboBox[i]->SelectString( -1, str); //line 2 
if(iCurIndex != -1)
    pComboBox[i]->GetLBText(iCurIndex , str); //line 3 
-----------------------------------------------------------------

#include <iostream>
using namespace std;
#define alive '1'		//This is to make it easier to set a cell to "alive" or "dead" by defining the words as variables equal to a symbol.
#define dead '0'

char currBoard[20][30];		//This is where all of the array variables are first defined that will be used later
char newBoard[20][30];
char a[20][30];
char b[20][30];
char c[20][30];
char d[20][30];

void printBoard(char a[20][30]);	//These are the four functions that are used in the program. They are defined later in the file.
void resetBoard(char b[20][30]);
int countNeighbors(char c[20][30],int x, int y);
void makeNewBoard(char c[20][30],char d[20][30]);

int main()
{
	
	int g,x,y,i;								
	resetBoard(currBoard);
	resetBoard(newBoard);

	cout << "Number of Generations: ";	//allows for the input of # of generations
	cin >> g;
	
	x=0;
	y=0;
	i=1;

	while((x>=0) && (y>=0))
	{		
		cout << "Enter point #" << i << ": ";	//Prompts the user to input each point where a cell is to be alive. It will continue to ask for points
		cin >> y >> x;							//until the point (-1,-1) is entered.
		currBoard[y][x]=alive;
		i++;
	}

	for (int i=0;i<g;i++)>
	{
		if (i%2 == 0)
		{
			printBoard(currBoard);				//This will print the first board (the original points the user entered. 
			makeNewBoard(currBoard,newBoard);   //then will switch to the "new board", then will continue to switch between 
		}										//the two boards for each generation.
		else
		{
			printBoard(newBoard);
			makeNewBoard(newBoard,currBoard);

		}
	}
}


void resetBoard(char a[20][30])	//this function will automatically set each cell on the board to equal dead, 
{								//and is called at the beginning of the program to reset the first board.
	int y,x;
	for(y=0;y<20;y++)
	{
		for(x=0;x<30;x++)
		{
			a[y][x]=dead;
		}
	}
}

void printBoard(char b[20][30])	//This function will take the current vaules set by "makeNewBoard" and print them onto the screen.
{	
	int y,x;
	for(y=0;y<20;y++)
	{
		for(x=0;x<30;x++)
		{
			cout << b[y][x];
		}
		cout<<endl;
	}
	cout<<endl;
}

int countNeighbors(char c[20][30],int y, int x) // This function will take each individual cell on the array and check all of its eight neighbors 
{												//to see if they are alive, then increment a counter.
	int prevx; 
	int prevy;
	int nextx ;
	int nexty ;
	prevy = (y-1 < 0 ? 19 : y-1);
	prevx = (x-1 < 0 ? 29 : x-1);	//this set of four statements will account for the edges of the board where the "neighbors" overlap.
	nexty = (y+1 >= 20 ? 0 : y+1);
	nextx = (x+1 >= 30 ? 0 : x+1);
	int neighbors=0;	//initializes the counter called "neighbors" which will hold the number of neighbors each cell has.


	if (c[y-1][x-1]==alive)
	{
		neighbors++;
	}
	if (c[y-1][x]==alive)
	{
		neighbors++;
	}
	if (c[y-1][x+1]==alive)
	{
		neighbors++;
	}
	if (c[y][x-1]==alive)
	{
		neighbors++;
	}
	if (c[y][x+1]==alive)
	{
		neighbors++;
	}
	if (c[y+1][x-1]==alive)
	{
		neighbors++;
	}
	if (c[y+1][x]==alive)
	{
		neighbors++;
	}
	if (c[y+1][x+1]==alive)
	{
		neighbors++;
	}
	return neighbors;	//returns the variable neighbors to be used in the makeNewBoard function later.
}

void makeNewBoard(char c[20][30],char d[20][30])	//this function calls on "countNeighbors" to use its count to decide whether 
{													//each new cell should be alive or dead.

	int neighbors;
	int y,x;
	for(y=0;y<20;y++)	//loops the following code until each cell in the row is checked.
	{
		for(x=0;x<30;x++) //loops the following code until each cell in the column is checked.
		{
			neighbors=countNeighbors(c,y,x);
			switch(neighbors)
			{
			case 0:
			case 1:
				d[y][x]=dead;
				break;
			case 2:
				if (c[y][x]==dead)
				{
					d[y][x]=dead;			// This switch statement will decide if the current (x,y) value should be set to 
				}							// "alive" or "dead" for the next board to be made, then sets that cell to the correct state.
				else						// Rules:
				{							// 1.) If a cell is alive and has 2 or 3 live neighbors it will stay alive.
					d[y][x]=alive;			// 2.) If a cell is alive and has 0 or 1 live neighbors it will die of loneliness.
				}							// 3.) If a cell is alive and has 4 or more live neighbors it will die due to overcrowding.
				break;						// 4.) Finally, if a cell is dead and has exactly 3 live neighbors it will be revived.
			case 3:
				d[y][x]=alive;
				break;
			case 4:
			case 5:
			case 6:
			case 7:
			case 8:
				d[y][x]=dead;
				break;
			}
		}
	}
}</iostream>