character pointer to string

[eagerlearner]

I know what is pointer, but I always blurred by character pointer to string. Can you tell me these accordingly ? Thanks.

What is the difference ?
char string[] = "abc"; // between this one and
char * string = "abc";

How come ?
This one work

const char * get()
{
	return "xyz";
}

int main()
{
	printf("%s",get());
	return 0;
}

But this one print out weird characters.

const char * get()
{
	string str = "xyz";
	return str.c_str();
}

int main()
{
	printf("%s",get());
	return 0;
}

Using std::string seems to be easier to manage but, what is the drawback of using std::string compare to char string[] ? Thanks.

[weaknessforcats]

Let's start here:

char string[] = "abc"; // between this one and
char * string = "abc";

The first is a local array of of 4 char containing abc and a null terminator.
The second is a pointer to a const array cotaining abc and a null terminator.

You canmake changes to the local array but you will crash trying to change the contents of the literal.

Remember, in C and C++, the name of the array is the address of element 0.
So, in both cases, the name string is the address of element 0 of the array. Therefore, the name string is a char* in both cases.

const char * get()
{
return "xyz";
}

This works because you are returning the address of the x. The literal is kept in the static memory pool and will exist after the function has completed.

const char * get()
{
string str = "xyz";
return str.c_str();
}

This fails because str is a local variable. It is kept in an area call a stack frame. The stack frame for a function contains all of the function arguments that were passed in plus all of the local variables and some other stuff. The stack frame is created when the function is called and destroyed when the function completes. With that in mind, here you are returning a char* that points to the x. Unfortunately, when the function completes, the stack frame is destroyed and the string str is returned to free memory. Those strange characters are whatever is in memory at the time you did the display.

This is a particularly bad bug. You see, memory isn't destroyed. It's just reused. That means returning a pointer to a local variable may actually work until that memory is reused. One time the program works, then next time it doesn't. The hard rule is to never return a pointer or a reference to a local variable.

[eagerlearner]

This works because you are returning the address of the x. The literal is kept in the static memory pool and will exist after the function has completed.

Thanks the explanation is very helpful. if the address of the x ONLY is returned why does the y and z get printed as well ? is the address of the y and z same as the x ?

[phiefer3]

Thanks the explanation is very helpful. if the address of the x ONLY is returned why does the y and z get printed as well ? is the address of the y and z same as the x ?

Because it's an array. You only need to return the address of the first element, the array can automatically access the rest of the elements because they come right after the first element in memory. Like was said, the name of an array is actually a pointer to the first element, so it's the same as that.

[scruggsy]

Thanks the explanation is very helpful. if the address of the x ONLY is returned why does the y and z get printed as well ? is the address of the y and z same as the x ?

Because of the way printf handles character arrays.
When you declare a string literal like "xyz", a non-printing NULL character is appended to the string to mark the end. So your string actually has 4 characters, and looks like this: "xyz\0" where "\0" represents the NULL.
When you pass a char pointer to printf, it starts at the first element and continues printing each character in sequence until it encounters that NULL.

[weaknessforcats]

Maybe further explanation.

An array is required to be contuguous in memory:

x y z \0

So if you have the address of the x, the char y is next door, z after that and finally the null terminator.

An array of char that has a final elemnet of 0 (\0), is called a C-string. Many functions with char* arguments assume the \0 is there so they process until they reach it. If it's not there, your program goes into the weeds.

If your is not an array of char, or is an array of char but does not have the null terminator, you will need to have the number of elements in addition to the address of the first char.

All arrays that are not arrays of char require the number of elements be known.

Lastly, you are using C++ and the string class. You should not be using printf() in C++. Use the << operator instead. Use string arguments rather than char* arguments.

The C++ string is a ton of code to manage an array of char. You can use the code already written or re-invent the wheel.

[eagerlearner]

Because of the way printf handles character arrays.
When you declare a string literal like "xyz", a non-printing NULL character is appended to the string to mark the end. So your string actually has 4 characters, and looks like this: "xyz\0" where "\0" represents the NULL.
When you pass a char pointer to printf, it starts at the first element and continues printing each character in sequence until it encounters that NULL.

Thanks now I am clearer. My simple class below is not working, it print out the strange characters. Is it because
m_url.substr(nS tart) return a copy of string "/mail/"
and "mail" is converted into C Null-terminated string,
the string is local to the function getFileName and it's destroyed as the function return. or am I wrong ? Thanks.

url.h

#include <string>

using namespace std;

class Url 
{
public:
	Url(const char *);
	const char *  getFileName() const;

private:
	string m_url;
};

url.cpp

#include <iostream>
#include "url.h"

Url::Url(const char * url)
{
	m_url = url;
}

//Get filename of the url e.g www.yahoo.com/mail/
//will return /mail/
const char * Url::getFileName() const
{
	int nStart;
	char * scheme = "://";
	if((nStart = m_url.find(scheme,0)) == string::npos )
	{
       ......
		return	m_url.substr(nStart).c_str();
	........
        }
        .......
	.......

}

int main()
{
	Url url("www.yahoo.com/mail/");
	cout << url.getFileName();
	return 0;
}

[weaknessforcats]

There were various bugs. This works.

1)I removed the char* and replaced them with string. You can always go back to char*.
2) I changed Url::getFileNam e() to do the substr only if the substr was found. Otherwise return an empy string.
3) You need to add 3 to nStart because the copy starts with the beginning of the sub-string, which was 3. I would add an argument for this to remove the hard-coded 3. That way you can use the function for different scheme. The scheme itself should be an argument.
4) Watch those naming conventions. nStart does not have to be an int.
Ditto for m_url. m_ does not mean a member variable. This silliness started at Microsoft by C programmers. A member variable is
this->variablename . A global variable is ::variablename and a local variable is variablename. The compiler can verify all of these.

Anything the compiler can't verify is a weakness.
[code=cpp]

class Url
{
public:
Url(string url);
string getFileName() const;

private:
string m_url;
};


//url.cpp

//Code: ( text )
#include <iostream>
//#include "url.h"

Url::Url(string url)
{
m_url = url;
}

//Get filename of the url e.g www.yahoo.com/mail/
//will return /mail/
string Url::getFileNam e() const
{
int nStart;
string scheme = "://";
if((nStart = m_url.find(sche me,0)) != string::npos )
{
// ......
return m_url.substr(nS tart + 3);
//........
}
// .......
// .......
return string(); //not found

}

int main()
{
Url url("http://www.yahoo.com/mail/");
string result = url.getFileName ();
if (result.size())
{
cout << result << endl;
}
else
{
cout << "Not Found" << endl;
}
return 0;
}
[/code]

[eagerlearner]

Thanks, I really learn lots from you today. It's important to have the class Url working, but it's even more important for me to understand why the class does not work previously, can you verified what I have asked previously is correct or wrong ?

The fourth one, so you mean using the this->variablename , ::variablename, variablename naming conventions is a better one ? it looks looks so graceful to me as well. Thanks.

[weaknessforcats]

The maain error was here:

if((nStart = m_url.find(sche me,0)) == string::npos )
{
......
return m_url.substr(nS tart).c_str();
........

Here the the substring was copied only if the scheme was not found. It should have been:
[code=cpp]
if((nStart = m_url.find(sche me,0)) != string::npos )
{
......
return m_url.substr(nS tart).c_str();
........
[/code]

Also, on this:

The fourth one, so you mean using the this->variablename , ::variablename, variablename naming conventions is a better one ?

This is not a naming convention. This is C++ code. this is a C++ keyword for the address of the object, -> is the C++ indirection operator, and :: is the C++ scope resolution operator.

[eagerlearner]

Sorry, I have not shown the important part, the actual code is like these. if the url is www.yahoo.com/mail/ the function should return /mail/
But what I get printed out is weird "h !!" characters. Thanks so much.

const char * Url::getFileName() const
{
	int nStart;
	char * scheme = "://";
	if((nStart = m_url.find(scheme,0)) == string::npos ) // protocol http:// or https:// not found
	{
		if((nStart = m_url.find("/")) == string::npos)
		{
			return "/";
		}
		else
		{
			return	m_url.substr(nStart).c_str();
		}
	}
	else 
	{
		nStart += strlen(scheme);
		if((nStart = m_url.find("/",nStart)) == string::npos)
		{
			return "/";
		}
		else
		{
			return m_url.substr(nStart).c_str();
		}
	}
}

int main()
{
	Url url("www.yahoo.com/mail/");
	cout << url.getFileName();
	return 0;
}

[weaknessforcats]

This code:

m_url.substr(nS tart).c_str();

doesn't work. True, m_url(nStart) returns a string but unless you capture that string it won't exist long enough to do the c_str() method.

You have to:
[code=cpp]
string answer = m_url.substr(nS tart);
const char* result = answer.c_str();
[/code]

But if your return the result, the answer string dies with the function and you again will get garbage in main().

I say again, the only safe way is to return a string. The string that is returned is a COPY of the string in the function. The same is true of the char*. When returned, it is a COPY of the char* inside the function. If the char* referred to a local variable, then that variable is not there after the function completes.

If you still insist on a char*, you will need to allocate memory yourself and delete it later (if you remember and if it is safe -- here starts memory management issues):
[code=cpp]
char* result = new char[answer.size() + 1];
strcpy(result, answer.c_str()) ;
[/code]

and you have converted C++ back to C.