Whats wrong with the Null pointer [closed] - c++

Question

Closed. This question is not reproducible or was caused by typos. It is not currently accepting answers.
This question was caused by a typo or a problem that can no longer be reproduced. While similar questions may be on-topic here, this one was resolved in a way less likely to help future readers.
Closed 8 years ago.
Improve this question
I was practicing C++ and find this task in the web. The question in of task is "What is the wrong with this code?"
#include <iostream>
void StrIn(char *sp)
{
sp = new char[256];
sp[0] = '1';
sp[1] = '2';
sp[2] = '\0';
}
int main()
{
char *pt=0;\\ something wrong here
StrIn (pt);
std::cout << pt[1];
delete[] pt;
return 0
}
First of all. I do not understand why StrIn do not changes values of elements pt[].
Second. Why program shouts down when
char *pt=0;
and works "fine" with
char *pt;
Obviously I do not understand something but I spend 4 hours on this task and don't get any closer to solution so asking you for help.
UPD:
Why the output for
std::cout << pt;
ending with "-" symbol and shows only sevral symbols inicializated in a row?

Answer 1

You're passing the pointer by value, so inside the function you're actually assigning to a new pointer, not the original one.
Change the function prototype to void StrIn(char *&sp).

Answer 2

The equivalent for your code with an integer:
#include <iostream>
void ReadInt(int i)
{
i = 2;
}
int main()
{
int i = 0;
ReadInt (i);
std::cout << i;
return 0
}
The problem here is that your are passing a copy of i, and changing it in ReadInt does not change the int in main.
There are 2 solutions:
Solution 1
Return the changed number:
int ReadInt()
{
return 2;
}
int main()
{
int i = 0;
i = ReadInt();
std::cout << i;
return 0
}
In your case:
char* StrIn()
{
sp = new char[256];
sp[0] = '1';
sp[1] = '2';
sp[2] = '\0';
return sp;
}
int main()
{
char* pt = 0;
pt = StrIn();
std::cout << pt[1];
delete[] pt;
return 0;
}
Solution 2
Pass the reference, or memory location of your variable.
For integer:
void ReadInt(int& i) which would be called like this: ReadInt(i)
//or
void ReadInt(int* i) which would be called like this: ReadInt(&i)
In your case:
void StrIn(char*& sp) which would be called like this: StrIn(pt)
//or
void StrIn(char** sp) which would be called like this: StrIn(&pt)
To get data that a double pointer points to you need to dereference the pointer.
char* deref = *(double_pointer);

Answer 3

I do not understand why Str do not changes values of elements pt[].
When Str is called, the value of pt is passed to it. pt is a pointer, so the value is an **address*. You are passing an address to Str. So far, so good.
Now in Str, what happens? You take your copy of the address, call it sp and immediately replace it with a new address (the one returned by new). All subsequent code in Str only modifies what is pointed at by that new address. The original address is untouched.
Then Str returns, the copy is discarded, and what was pointed at by the copy is left in memory forever (until the program ends).
The rest of the program deals with the original address.
Why program shouts down when char *pt=0; and works "fine" with char
*pt;
It's just undefined (i.e. more or less random) behaviour in both cases. In main, you use the original address, regardless of what happens with the copy in Str. A 0 address is not valid for the [] operation, neither is using an uninitialised variable.
The only real difference is with delete[], which will work fine by doing nothing with a null pointer and yield undefined behaviour with an uninitialised variable.
Obviously i do not understand somthing but i spend 4 hours on this
task and dont get any closer to solution so asking u for help.
You are mistaking real strings with char arrays or pointers (i.e. memory addresses).
In C++, when you need strings, use the std::string class and everything will work as expected.
When you use char arrays or pointers, you need to learn a lot more about language details. Start with a good tutorial or a good book. Some hours are not enough, but some days should suffice.