tic-tac-toe

[bool maybe]

I'm in the initial stages of programming a tic-tac-toe game and for now I'm trying to get this bit of code to work:

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

const short DIMENSION = 3;

//initialize tic-tac-toe board
void initialize_board(char position[][DIMENSION]);

//convert digit (1-9) of type short to a digit (1-9) of the type char
//returns the char type of the digit
char convert_digit(short digit);


int main()
{
	using namespace std;

	char control = 'y';//this variable is used by user to stay in or exit out of do-while loop

	do
	{
		char position[DIMENSION][DIMENSION];

		//TESTING
		for(short i = 0; i < DIMENSION; i++)
		{
			for(short j = 0; j < DIMENSION; j++)
			{
				cout << position[i][j];
			}
		}

		cout << "\n\nWould you like to run the program again? (Y/N): ";
		cin >> control;
		while ((control != 'y') && (control != 'n'))
		{
			cout << "Incorrect input. Would you like to run the program again? (Y/N): ";
			cin >> control;
			control = tolower(control);
		}
		
	}while(control == 'y');
	
	cout << "Press key to exit: ";
	char exit;
	cin >> exit;

	return 0;
}

void initialize_board(char position[][DIMENSION])
{
	using namespace std;
	short count = 1;
	for(short i = 0; i < DIMENSION; i++)
	{
		for(short j = 0; j < DIMENSION; j++)
		{
			position[i][j] = convert_digit(count);
			count++;
		}
	}
	return;
}

char convert_digit(short digit)
{
	using namespace std;
	
	if(digit == 1)
	{
		return '1';
	}
	else if(digit == 2)
	{
		return '2';
	}
	else if(digit == 3)
	{
		return  '3';
	}
	else if(digit == 4)
	{
		return '4';
	}
	else if(digit == 5)
	{
		return '5';
	}
	else if(digit == 6)
	{
		return '6';
	}
	else if(digit == 7)
	{
		return '7';
	}
	else if(digit == 8)
	{
		return '8';
	}
	else if(digit == 9)
	{
		return '9';
	}
}

I wanted to initialize the values on the tic-tac-toe board to values 1-9, like on a number pad (minus the zero) but when I output the values in the 2-dimensional array I get vertical bars. What's wrong with my code?

[dangrr888]

Hi bool maybe,

it appears that you are not initializing your array position with initialize_board. I prefer to use vector than arrays, and here you can just use a vector<vector<int> > to store your keypad. If you then plan to do arithmetic with the stored values you then won't need to convert them using your convert_digit.

Also, since your dealing with built-in types in convert_digit it might be more efficient to use a switch statement.

Lastly, you don't need the using namespace std; statements within each body of your functions since you are using the std namespace throughout. Hence a single statement just after the include directives is sufficient here.

Here's my version:

#include <iostream>
#include <string>
#include <vector>

using namespace std;

const size_t DIM = 3;

vector<vector<int> > initialize_board(size_t wd, size_t ht)
{
  int count = 1;
  vector<vector<int> > ret;

  for(size_t i = 0; i != ht; ++i)
    {
      vector<int> temp;
      for(int i = 0; i != wd; ++i)
        temp.push_back(count++);
      ret.push_back(temp);
    }

  return ret;
}

int main()
{
  char control;//this variable is used by user to stay in or exit out of do-while loop                                  

  do
    {
      vector<vector<int> > position(initialize_board(DIM, DIM));

      for(size_t i = 0; i != DIM ; i++)
        {
          for(size_t j = 0; j != DIM; j++)
            {
              cout << position[i][j];
            }
          cout << endl;
        }

      cout << "\nWould you like to run the program again? (Y/N): ";
      cin >> control;
      while (control != 'y' && control != 'n')
        {
          cout << "Incorrect input. Would you like to run the program again? (Y/N): ";
          cin >> control;
        }

    } while(control == 'y');

  return 0;
}

Cheers.

[bool maybe]

I appreciate the response dangrr888 but I haven't covered vectors in depth yet and I would like to solve this problem using arrays.

I know that I can use one "using namespace std;" command but my book tells me it's a good habit to write them for every function.

Does anyone know why my array is not getting initialized?

Also my array needs to be of the type char because later I'm going to add code that will allow the user to change the numbers to "x"s and "o"s.

[bool maybe]

I see what you mean now dangrr888 about not initializing. I don't know how I could have missed that. Thanks anyway for your help. Here's the working code more or less (there are still a few kinks I'm trying to work out but they're minor):

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>

const short DIMENSION = 3;

//initialize tic-tac-toe board
void initialize_board(char position[][DIMENSION]);

//convert digit (1-9) of type short to a digit (1-9) of the type char
//returns the char type of the digit
char convert_digit(short digit);

//clears screen
void clr();

//displays board
void disp(char position[][DIMENSION]);

//display upper border
void upper_lower();

//display section of boards with squares
void square_section(char position[][DIMENSION], short row);

//displays midsection border
void midsection();

//places an "x" or "o" on the board
void move(char position[][DIMENSION], bool vacant[][DIMENSION], short& digit, bool x_turn);

//initializes "vacant" array to have all values be true
void initialize_vacant(bool position[][DIMENSION]);

//takes a digit symbolizing a position (1-9) and returns a 2d coordinate
void coordinate_conversion(short digit, short& row, short& column);

//returns true if a player won by getting a horizontal combination
//returns false otherwise
bool horizontal_test(char position[][DIMENSION]);

//returns true if a player won by getting a vertical combination
//returns false otherwise
bool vertical_test(char position[][DIMENSION]);

//return true if a player won by getting a diagnol combination
//returns false otherwise
bool diagnol_test(char position[][DIMENSION]);

//returns true if someone won
//returns false otherwise
bool test_win(char position[][DIMENSION]);

//returns true if there are no more vacant spaces left
//returns false otherwise
bool test_vacancy(bool vacant[][DIMENSION]);

int main()
{
	using namespace std;

	char control = 'y';//this variable is used by user to stay in or exit out of do-while loop

	do
	{
		short digit;
		char player;
		bool win = false;
		bool x_turn = false;
		char position[DIMENSION][DIMENSION];
		bool vacant[DIMENSION][DIMENSION];
		initialize_board(position);
		initialize_vacant(vacant);
		bool vacant_spaces = true;

		while(!win && vacant_spaces)
		{
			if(x_turn)
			{
				cout << "Player: x\n";
				player = 'x';
				x_turn = !x_turn;
			}
			else
			{
				cout << "Player: o\n";
				player = 'o';
				x_turn = !x_turn;
			}
			clr();
			disp(position);
			cout << "Enter location on board: ";
			cin >> digit;
			move(position, vacant, digit, x_turn);
			win = test_win(position);
			vacant_spaces = test_vacancy(vacant);
			if(win)
			{
				cout << "Player " << player << " wins!\n";
			}
			else if(!vacant_spaces)
			{
				cout << "DRAW\n";
			}
		}

		cout << "\n\nWould you like to run the program again? (Y/N): ";
		cin >> control;
		while ((control != 'y') && (control != 'n'))
		{
			cout << "Incorrect input. Would you like to run the program again? (Y/N): ";
			cin >> control;
			control = tolower(control);
		}
		
	}while(control == 'y');
	
	cout << "Press key to exit: ";
	char exit;
	cin >> exit;

	return 0;
}

void initialize_board(char position[][DIMENSION])
{
	using namespace std;
	short count = 1;
	for(short i = 0; i < DIMENSION; i++)
	{
		for(short j = 0; j < DIMENSION; j++)
		{
			position[i][j] = convert_digit(count);
			count++;
		}
	}
	return;
}

char convert_digit(short digit)
{
	using namespace std;
	
	if(digit == 1)
	{
		return '1';
	}
	else if(digit == 2)
	{
		return '2';
	}
	else if(digit == 3)
	{
		return  '3';
	}
	else if(digit == 4)
	{
		return '4';
	}
	else if(digit == 5)
	{
		return '5';
	}
	else if(digit == 6)
	{
		return '6';
	}
	else if(digit == 7)
	{
		return '7';
	}
	else if(digit == 8)
	{
		return '8';
	}
	else if(digit == 9)
	{
		return '9';
	}
}

void clr()
{
	using namespace std;

	cout << string(50, '\n');
	return;
}

void disp(char position[][DIMENSION])
{
	using namespace std;
	upper_lower();
	square_section(position, 0);
	midsection();
	square_section(position, 1);
	midsection();
	square_section(position, 2);
	upper_lower();
	return;
}

void upper_lower()
{
	using namespace std;
	cout << "-------\n";
	return;
}

void square_section(char position[][DIMENSION], short row)
{
	using namespace std;
	cout << "|" << position[row][0] << "|" << position[row][1] << "|" << position[row][2] << "|\n";
	return;
}

void midsection()
{
	using namespace std;
	cout << "+-+-+-+\n";
	return;
}

void move(char position[][DIMENSION], bool vacant[][DIMENSION], short& digit, bool x_turn)
{
	using namespace std;
	
	char player;
	short row, column;

	if(x_turn)
	{
		player = 'x';
	}
	else
	{
		player = 'o';
	}

	coordinate_conversion( digit, row, column);
	while(!vacant[row][column])
	{
		clr();
		cout << endl << "Invalid position.\n";
		disp(position);
		cout << "Player " << player << " -- Enter another choice: ";
		cin >> digit;
		coordinate_conversion( digit, row, column);
	}
	position[row][column] = player;
	vacant[row][column] = false;
	
	return;
}

void initialize_vacant(bool position[][DIMENSION])
{
	using namespace std;
	for(short i = 0; i < DIMENSION; i++)
	{
		for(short j = 0; j < DIMENSION;  j++)
		{
			position[i][j] = true;
		}
	}
	return;
}

void coordinate_conversion(short digit, short& row, short& column)
{
	using namespace std;
	if(digit == 1)
	{
		row = 0;
		column = 0;
	}
	else if(digit == 2)
	{
		row = 0;
		column = 1;
	}
	else if(digit == 3)
	{
		row = 0;
		column = 2;
	}
	else if(digit == 4)
	{
		row = 1;
		column = 0;
	}
	else if(digit == 5)
	{
		row = 1;
		column = 1;
	}
	else if(digit == 6)
	{
		row = 1;
		column = 2;
	}
	else if(digit == 7)
	{
		row = 2;
		column = 0;
	}
	else if(digit == 8)
	{
		row = 2;
		column = 1;
	}
	else//(digit == 9)
	{
		row = 2;
		column = 2;
	}
	return;
}

bool horizontal_test(char position[][DIMENSION])
{
	using namespace std;
	for(short i = 0; i < DIMENSION; i++)
	{
		short match = 0;
		for(short j = 1; j < DIMENSION; j++)
		{
			if(position[i][0] == position [i][j])
			{
				match++;
			}
		}
		if(match >= 2)
		{
			return true;
		}
	}
	return false;
}

bool vertical_test(char position[][DIMENSION])
{
	using namespace std;
	for(short j = 0; j < DIMENSION; j++)
	{
		short match = 0;
		for(short i = 1; i < DIMENSION; i++)
		{
			if(position[0][j] == position [i][j])
			{
				match++;
			}
		}
		if(match >= 2)
		{
			return true;
		}
	}
	return false;
}

bool diagnol_test(char position[][DIMENSION])
{
	using namespace std;
	short match(0);
	for(short i = 1; i < DIMENSION; i++)
	{
		if(position[i][i] == position[0][0])
		{
			match++;
		}
	}
	if(match == 2)
	{
		return true;
	}

	match = 0;
	for(short k = 1; k < DIMENSION; k++)
	{
		if(position[0][2] == position[k][DIMENSION-1-k])
		{
			match++;
		}
	}
	if(match == 2)
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool test_win(char position[][DIMENSION])
{
	using namespace std;
	if((diagnol_test(position)) || (vertical_test(position)) || (horizontal_test(position)))
	{
		return true;
	}
	else
	{
		return false;
	}
}

bool test_vacancy(bool vacant[][DIMENSION])
{
	using namespace std;
	for(short i = 0; i < DIMENSION; i++)
	{
		for(short j = 0; j < DIMENSION; j++)
		{
			if(vacant[i][j] == true)
			{
				return true;
			}
		}
	}
	return false;
}