OK. I'll try to explain my problem in a short way. I have a function in my game which asks the players name. It has a char array of 25 chars which is modified by inputing the name. The function returns the array. Another function which calls that function calls also strcpy() to copy the returned string to another string.
Nothing seems to work. The string for players name contains (null).
Hmmm...Here is the prototype of code:
a_function(){
...
char * player_name;
...
strcpy(player_name,ask_name());
...
//The player_name has the value null here
}

ask_name(){
char str[25]="Put you name here ";
...
//Modify str array here
...
return(str);
}

> char * player_name;
This creates a pointer which can be used to point to a char or an array of chars (ie. a string), but it does not allocate room for the chars themselves. Do this:
char player_name[25];
> strcpy(player_name,ask_name());
Fine.
> //The player_name has the value null here
You're lucky you got away with it :-) I suspect you're using DJGPP and running in a Windows DOS box - plain DOS and any other platform would have segfaulted or something.
> ask_name(){
Woah! Don't forget to specify what type the function is.
char *ask_name() {
> char str[25]="Put you name here ";
static char str[25];
strcpy(str,"Put your name here");
Don't forget the 'r' on 'your'.
Unless you declare it static, the string's memory will no longer be allocated on return. You'd get away with it (since it was on the stack), but it's a bad habit and is not guaranteed to work on all platforms.
By declaring it static, you're telling the compiler to put it somewhere safe so that it will retain its value from one call to the next. Hence you will want to reinitialise it each time, but typing ="..." will only initialise it the first time.
> //Modify str array here
No problem.
> return(str);
> }
Fine.
There is however another method you may find more useful in this case. You could do the following:
void ask_name(char *name) {
strcpy(name,"Put your name here");
...
// modify name here - you can access it like an array, using name[0], name[1], etc.
...
// Do not type "return name;"
}
a_function() {
...
char player_name[25];
...
ask_name(player_name); /* you are passing a pointer to the string. ask_name() cannot modify the parameter itself (ie. the pointer), but it can change what the pointer refers to (ie. the string). */
...
}

Remember that declaring a variable static is nearly the same than declaring it global. So you can access the variable no matter where. I will recommend CorsairK8's way... just remember to set the pointer to NULL once you have freed the memory with "free". If you want to use BDavis' way, I would declare it global. Statics will only be "recognized" once the function was called, and that can create some problems if you try to access it before it is "created".
If I were you:
#define NAME_LENGTH 24
char *ask_player_name() {
char *player_name;
player_name=(char *)malloc(NAME_LENGTH+1);
if (player_name != NULL) {
// Ask the player to give out his name
// and assing it to player_name
}
return (player_name);
}

void a_function() {
char *name;
// See, no need of strcpying it. Doing that will make
// a very nice buffer overrun cackle
name = ask_player_name();
if (name!=NULL) {
...
...
free (name);
}
return;
}
RB

Just a bit of clarification:

char *blah="hello, world";

is correct: this is a pointer that points to a string constant, and this data can not be modified.

char blah[222]="hello, world";

is correct and is a pointer pointing to a non constant (eg you can strcpy to it) portion of memory.

tell me if a goofed

or the stl string, if you want something portable and widely used.

Strings are very simple, and I think that there is no need for a library to handle string manipulation. It only slows things down when you can handle the string with the standard rtl string functions (string.h). Strings are very important in any kind of programming, you should learn how to use them and understand them since they are a fundamental of the c language. Not knowing how to use strings is like not understanding how to use a 'struct' or use classes.

Amarillion: Basic is not better than C when using string. C allows you to dynamically allocate strings that are very large, and you can use as much memory as the computer has free. BASIC limits you to 64k maximum. There are alot of very bad limits to basic, not to mention that basic is very slow and impossible to create a game with it. There are exceptions, such as using libraries written in C or assembler (directx, and some other qbasic library support this) but the actual game itself is severly limited and can be incredibly slow. Granted, C can give you too much control sometimes and even cause you to crash the computer when doing something incorrectly (its happen to me many times when accessing memory im not allowed to, or dividing by zero, probably two of the most common problems)

wit,
again, you're misusing pointers. you don't need the '*' where you declare that array. by default, i'll bet that the array is initialized to zero, and i'm surprised that when you go modify it, you're not getting a seg fault.
try:

struct SCORE high_scores[10];

and then to modify an entry:

high_scores[0].credits = 10;

if you want it to be an array of pointers, then you must allocate a SCORE struct to each pointer:

struct SCORE * high_scores[10];
for(i=0;i<10;i++){
high_scores[i] = (struct SCORE *)malloc(sizeof(struct SCORE));
}

after that, each entry holds a unique pointer to memory that is SAFE to use
although, i don't understand why you need an array of pointers. if you need a pointer to satisfy some other type of function that needs a pointer, you can use the '&' modifier to get the address of anything to pass.
for instance, if you want to set all the bytes of one of your structures to zero, you can do this:

struct SCORE zero_me;
memset(&zero_me, 0, sizeof(struct SCORE));

or if you want to set just the name to all blanks, you can do this:

memset(&(zero_me.name), ' ', sizeof(zero_me.name));

you have to remember that a pointer is just four bytes of memory, like a long int. all it stores is an address, and until you set that address to something useful with 'malloc' or by assigning it to allocated storage, it will most likely point to storage that you don't want to use.
here's yet another way to look at what you're asking for. it's valid code, but i don't recommend doing it this way, just as a demonstration:
[i]
struct SCORE * high_scores[10];
struct SCORE hs0;
struct SCORE hs1;
struct SCORE hs2;
struct SCORE hs3;
struct SCORE hs4;
struct SCORE hs5;
struct SCORE hs6;
struct SCORE hs7;
struct SCORE hs8;
struct SCORE hs9;
high_scores[0] = &hs0;
high_scores[1] = &hs1;
high_scores[2] = &hs2;
high_scores[3] = &hs3;
high_scores[4] = &hs4;
high_scores[5] = &hs5;
high_scores[6] = &hs6;
high_scores[7] = &hs7;
high_scores[8] = &hs8;
high_scores[9] = &hs9;
[i]
the above is valid because you have an array of ten pointers. then you have ten structures statically allocated. then you assign the address of these ten structures to the ten 'slots' in the array. now, all the pointers hold addresses of valid storage of the right size. however, it's a terribly ugly way to code it
good luck!
jase

Thanks again!

Does anyone know if DJGPP GCC and/or Ming GCC recognise the optimisation in the first one?

mingles,

%hanks a lo%!, now my k#yboard do#sn'% s##m %o work %h# way i% us#d to!

plus, %h# %as%# on my %ongu# is v#ry disgus%ing...

pl#as# %ry %o b# mor# h#lpful n#x% %im#

I am writing to you to apologise from the heart of my bottom for posting such bad language on this forum (especially to WIT)

I believe that this is the correct code to type in your program:
a_function(){
...
char * player_name;
...
strcpy(player_testicles,ask_name());
...
//The player is a fucknut
}

ask_name(){
char str[25]="Put you name here ";
ps WIT is fucknut

And back to my question:

Does anyone know if DJGPP GCC and/or Ming GCC recognise that string[2] can be optimised to *(string+2) ?

That's Ming short for MingW32, not Mingles.

They should, but do they?
Say string points to 0x100.
MOV 0x100[2],0
MOV 0x102,0
Sorry for the sloppy syntax. Basically I mean that the assembler can refer to element 2 in an array based at the constant address 0x100, or it can refer to address 0x102 directly. The question is whether the compiler realises that the first instruction can be replaced with the second one, which could be more efficient.