# strings and loops...

• 12-12-2005
twomers
strings and loops...
Hi, I'm writing a program with 8 strings (from a to h) and I want to be able to edit elements, copy elements and delete elements from one string to another what not. but the only way I can think of for doing it is to have loads of loops which makes the program very ineloquent and messy.

it's a very basic chess program. the user says they want to move (for example) from g1 to f1. I have a loop that goes something like

(wm is the white move [a string with two elements, a letter and number], mp is the moving piece, a, b, ... g, h are strings of 12 elements each)

Code:

```if (wm[0]=='a') {                                 mp=a[wm[1]-48];         a[wm[1]-48]=' '; }```
I have one of those for a, b, c, d,e, f, g and h, but I want a loop which will do it for me. this equates the moving piece (mp) to the element number you specify in wm[1] in a. as you can see with there being 8 strings, there are a lot of (8 of) these loops. is there a way to do a for loop for string names? If I do it with a letter, it won't work cause the letter is only a sincge character, not a string.
• 12-12-2005
twomers
PS I hope I'm being clear!
• 12-12-2005
quzah
Why aren't you using a two dimensional array for your chess board instead of a string?

Quzah.
• 12-12-2005
twomers
to be honest, they kinda confuse me. is it easier to do that with an array?
• 12-12-2005
itsme86
You could just do:
Code:

`char board[8][8];`
Then if the first dimension is your a-h and the second is 0-7 you could just do:
Code:

`board[wm[0] - 'a'][wm[1] - '0'] = ' ';`
P.S. -'0' is clearer than -48 to most people.
• 12-12-2005
quzah
Code:

`char onedee[ SIZE ];`
Read it from right to left.
An array SIZE elements big, called onedee of type char. You can access each element of the array by doing:
Code:

```x = onedee[ SOMENUMBER ]; /* Get the value in slot SOMENUMBER and put it in x. */ onedee[ SOMENUMBER ] = x; /* Put the value of x in slot SOMENUMBER. */```
The only "hard" thing to rememeber, is that you start counting from zero up trough SOMESIZE-1. Thus, if you have an array of 8 items, you have valid elements:
Code:

```onedee[ 0 ] onedee[ 1 ] ... onedee[ 7 ]  /* if SOMESIZE is 8, you get up to 8-1 to access... */```
Two dimensional arrays are done exactly the same way, but you have a "row" element also.
Code:

`char twodee[ ROW ][ COLUMN ];`
Think of it as a grid, such as graph paper, or the pixels of your monitor. Again, you get 0 through SIZE-1 for both accessors. So, if we had an 8 by 8 grid, we would get:
Code:

```twodee[ 0 ][ 0 ] twodee[ 0 ][ 1 ] ... twodee[ 0 ][ 7 ]  /* all the elements in the first row... */ twodee[ 1 ][ 0 ] twodee[ 1 ][ 1 ] ... twodee[ 1 ][ 7 ] /* all the elements in the second row... */ ... ... twodee[ 7 ][ 7 ] /* up through the very last item in the last row... */```

Quzah.