Thread: I dont understand a piece of this code

Code:

void morse_code_letters(char morse_strings[91][6])
{
	//morse code letters using string copy
	strcpy (morse_strings['A'], ".-");
	strcpy (morse_strings['B'], "-...");
	strcpy (morse_strings['C'], " -.-.");
	strcpy (morse_strings['D'], "-..  ");
	strcpy (morse_strings['E'], ".");
	strcpy (morse_strings['F'], "..-.");
	strcpy (morse_strings['G'], "--.");
	strcpy (morse_strings['H'], "....");
	strcpy (morse_strings['I'], "..");
	strcpy (morse_strings['J'], ".---");
	strcpy (morse_strings['K'], "-.-");
	strcpy (morse_strings['L'], ".-..");
	strcpy (morse_strings['M'], "--");
	strcpy (morse_strings['N'], "-.");
	strcpy (morse_strings['O'], "---");
	strcpy (morse_strings['P'], ".--.");
	strcpy (morse_strings['Q'], "--.-");
	strcpy (morse_strings['R'], ".-.");
	strcpy (morse_strings['S'], "...");
	strcpy (morse_strings['T'], "-");
	strcpy (morse_strings['U'], "..-");
	strcpy (morse_strings['V'], "...-");
	strcpy (morse_strings['W'], ".--");
	strcpy (morse_strings['X'], "-..-");
	strcpy (morse_strings['Y'], "-.--");
	strcpy (morse_strings['Z'], "--..");
	// morse code numbers using string copy
	strcpy (morse_strings['1'], ".----");
	strcpy (morse_strings['2'], "..---");
	strcpy (morse_strings['3'], "...--");
	strcpy (morse_strings['4'], "....-");
	strcpy (morse_strings['5'], ".....");
	strcpy (morse_strings['6'], "-....");
	strcpy (morse_strings['7'], "--...");
	strcpy (morse_strings['8'], "---..");
	strcpy (morse_strings['9'], "----.");
	strcpy (morse_strings['0'], "-----");
	// morse code characters using string copy
	strcpy (morse_strings['.'], ".-.-.-");
	strcpy (morse_strings[','], "--..--");
	strcpy (morse_strings['?'], "..--..");
	strcpy (morse_strings[' '], " ");
}

I dont understand why the [91] and [6] are there. What do the numbers mean? and what do they do?

It's an array... check your C textbooks or tutorials for the section on arrays.

P.S. ... please don't use huge characters. I can almost guarantee they have the exact opposite effect of the one you want.

If you look up ASCII character codes for 'A' through 'Z' you will find they run from 65 to 90. So, if your compiler works with the ASCII character set, morse_strings['Z'] is equivalent to morse_strings[90]. Since array indexing in C starts at zero, the first dimension of morse_strings needs to be at least 91. The codes for numeric digits and punctuation characters happen to be smaller than 65 in the ASCII character set.

The [6] represents the maximum length of buffers for the individual strings to hold individual codes. Whoever wrote this code got that dimension wrong. The dimension should be at least 7 - the last few codes being copied are strings of length 6. strcpy() also copies a trailing nul (zero) character, so will copy seven characters for the last four codes.

Even if you fix the error with [6] versus [7], the code is only guaranteed to work if your compiler supports the ASCII character set. Whoever wrote your code made the mistake of neglecting the possibility that some compilers support different character sets.

Originally Posted by CommonTater

By using the ['A'] method of indexing it doesn't matter what the value of A is so even with non-ascii character sets the lookup table still works.

No, it matters what the value of 'A' is, because that value will be the index: on another character set, this could result in array out of bounds access. The problem does not stem from the expression morse_strings['A'] alone: the problem is also due to char morse_strings[91][6]. That magic number 91 makes an assumption about the character set which theoretically is not guaranteed. On the other hand, if the mapping went through a function that could guarantee a correct mapping, this problem would disappear.

Originally Posted by guitargod

Next up [91] and [6] are the sizes because it is a pretty safe size. See how the stuff you're copying in never exceeds 6 characters and the ASCII of all the characters used in addresses lies within 91.

You might want to read grumpy's post #3.

Originally Posted by guitargod

But I on the contrary feel the dimensions are perfect;

I see. How do you address grumpy's assertion that 7 is required because of the null character?

Code:

#include <stdio.h>

int main () 
{
   struct foo {
      char arr[10];
      int k;
   } bar = { "laserlight", -1 };
   printf("%s", bar.arr);
   return 0;
}

I can't say for sure since we're going beyond the arrays limits and the compiler might catch that initialization at compile time, but my hunch is that printf is not normal. It might segfault, it might look weird, it should do nothing at all! But for the final time: Zero is necessary, and you have to put it in.

Originally Posted by guitargod

Output- LASERLIGHT

A null character isn't NECESSARY!
When the siz eof the array is more than what we've filled, the compiler puts it in!!

You're in the realm of undefined behaviour. Initialising arr with "LASERLIGHT" is fine (except that you got that wrong: the string literal should not be in braces), since I recall that as a special exception the null character in the string literal will not be written to arr[10]. However, printing arr with printf("%s", arr) results in undefined behaviour since the contents of arr is not a null terminated string (note that taking the address of arr is wrong). It so happens that it works for you, but for me I get "LASERLIGHT@" (note the '@').

guitargod: you're not paying attention. It doesn't matter what program you show us: you're wrong. Any program output that you provide is just by luck. If you want to try finding a case where a problem is demonstrated, try creating arrays before and after arr, then print their contents. Aligning the size of the arrays to word boundaries may also help.