Function with char *

[e66n06]

if i have a class that has this function

        void SetText(char *txt){Text=txt;};

and this memeber

	char *  Text;

and i then want to call the function

why do i have problems if i do something like this:

char temp[256];
int num = 100;
sprintf(temp,"number is: %d",num);
object->SetText(temp);

when i tried to do this the objects member Text just go set to nothing.

is there something wrong with my code?

[MacGyver]

If you have a class, then it's C++, not C, and you probably should be using std::string and not char *'s whenever possible.

[e66n06]

is there a std::string function like sprintf ??

[matsp]

Let me guess, the code with sprintf() is in a function that gets called from somewhere else, and when you look at "Text", it's outside this function - am I correct?

If so, you are storing the address of "temp", which is a local variable in a function. This variable doesn't exist once you are outside the function, and the memory that you've save will be overwritten by other local variables in some other function at the next function call.

You probably want allocate some memory and copying the string instead...

--
Mats

[MacGyver]

is there a std::string function like sprintf ??

You would use stringstreams I think instead of a direct function call.

[e66n06]

Text is the memeber of the class

also i thought string streams are for cout and cin ??

how can i easily input an int into a string? to do i have to use itoa()

[e66n06]

the thing i found was it worked if i did:

object->SetText("hello");

but not

object->SetText(temp);

[MacGyver]

Because similar to what matsp said, you're messing around with local variables that get corrupted. String literals are generally read-only memory stored somewhere special.

Using std:string would make this slightly easier for you to handle without knowing the underlying mechanisms (although you can still break it).

[matsp]

Yes, because temp is a local variable in a function, and thus "disappears" after you leave that function.

As to how to use stringstream:

....
  stringstream ss;
  string temp;
  int num = 100;
  ss << num;
  ss >> temp;
...

Note that temp is still a local variable, so you still need to copy (the content of) it to make it "permanent".

--
Mats

[e66n06]

so temp is a variable local to the function, so it will dissapear right?

but the call to

object->SetText(temp);

happens before the function finishs

so i don't understand why it does not work?

[MacGyver]

Let's work with something easier as an example. Say an int. Let's say we have this code:

int x = 5;
dosomething(&x);

Now let's say x has an address of 0x12341234. Fair enough? Now the function dosomething() is defined like this:

void dosomething(int *p)
{
	someglobalintptr = p;
}

That saves the value of the address passed to it, right? That means someglobalintptr will contain the value 0x12341234.

Let's say later on in your code, a function is called that uses local variables. Let's pretend it's called performcalculations() and is defined something like this:

void performcalculations()
{
	int y = 100;

	.....
}

y might now have the address 0x12341234. Because x, the local variable of the first section of code is gone, the memory will be reused by other local variables (I'm making this extremely simple).

So later on if you print the value of someglobalintptr:

printf("*someglobalintptr = %d\n", *someglobalintptr);

You'll end up what is inside address 0x12341234. Which could be y instead of x.

[matsp]

so temp is a variable local to the function, so it will dissapear right?

but the call to

object->SetText(temp);

happens before the function finishs

so i don't understand why it does not work?

But you are taking the address of temp (because temp is an array, it is passed as the address of the first element), and you are stuffing that address into Text. Text now contains the address of temp. Fine. Now we leave this function, and temp is no longer valid - the memory address is obviously still ok to be used, but at some point, it will be re-used for something else - so the content of the memory that was temp a little while ago, is now overwritten with something else - highly probably not even a text-string, and thus your "Text" is no longer pointing to a text-string.

--
Mats

[e66n06]

ok, i think i understand now,

it's because the function (char* txt) takes an address, not an actuall string of text.

my only question is, so why does it work for something like this

object->SetText("hello");

also thanks very much for the help

[MacGyver]

As I said already, string literals, which are the text with quotes around them, are really stored somewhere else. They are not stored with local variables.

For example:

#include <stdio.h>

int main(void)
{
	char *szMsg = "Testing, 1 2 3...\n";
	printf("szMsg = &#37;s\n", szMsg);
	return 0;
}

Now what really happens is the compiler will take "Testing, 1 2 3...\n" and put it in a special location which is generally read-only. It will take the address of it, though, and put the address inside szMsg. Since the string literal is always available because it's part of the .exe or equivalent binary executable, you're ok.

The variable szMsg may disappear when its function ends, but the contents, which is an address of a location of the string literal "Testing, 1 2 3...\n" is still valid after a local function ends (although that's kind of pointless for an example with main()).

[matsp]

Because "hello" is a "string literal", which means that it's a piece of text that you put in the source-code, and it's stored somewhere in the binary (executable) file that gets loaded when you run your program. The address of this is a permanent place in the memory in your applicaton, so it doesn't get reused for something else when you leave the function.

Actually, if you were to do something like this:

object->SetText("Hello"); 
object1->SetText("Hello");
...
object9->SetText("Hello");

You would probably find that all of the "Text" members of the ten different objects are all pointing to the same place (slightly dependant on the compiler).

You would also find that if you tried to do something like this:

...
   Text[1] = 'a';
....

This would fail, rather than change the text from "Hello" to "Hallo" as you'd expect it to do.

--
Mats