Confusing char array

[abdul]

I have a function inside a class called "GetCaption" that lets the user retrieve current text assigned to a button. The caption is stored in a varible in the class as:

char *caption; 

Then the "GetCaption" function is like this:

    char  CGButton::GetCaption()
    {
            if (CGButton::Handle == NULL)
        {
            return NULL;
        }
        else
        {
            return (char)CGButton::caption;
        }
    } 

Now I want to use this function like this but it's giving me an eror message "Unhandled exception in...":

    MessageBox(NULL,(char*)mybutton.GetCaption(),"hello",MB_OK); 

[Jop]

Are you sure the handle exists and the appropiate code runs?

and hmm shouldn't you dereference the pointer before returning it because the pointer will go out of scope?

also, I think the function can be shortened to:

char  CGButton::GetCaption()
    {
            if (CGButton::Handle == NULL)
                    return NULL;
         return (char)*CGButton::caption; //Notice the derefencing, try it.
    } 

[CornedBee]

That returns only the first character. Why not return a char*? (Or const char* if you don't want the string to be edited.)

[parksie]

You shouldn't be returning a pointer anyway, since the object might go out of scope.

[CornedBee]

Well, I think it is different when returning a member variable (that's what the char pointer is).
But in this case (MFC extension class) it is better to store the caption in a CString and return that.

[parksie]

Just as an example of what I usually do and what I think you mean (feel free to pick holes):

class thingie {
public:
    thingie(const string &cap) : m_caption(cap) { }

    thingie& operator=(const thingie &ref) {
        if(this == &ref) return *this;

        m_caption = ref.m_caption;
        return *this;
    }

    const string& caption() const { return m_caption; }

    // mutator method if you want it
    void caption(const string &c) { m_caption = c; }

private:
    string m_caption;
};

For the accessor, this means that you're not penalised if you only need it during the lifetime of the object, but can persist it if you want.

The standard strings can be easily replaced with a CString in that (it's the return-by-const-reference that's important here).

[abdul]

Actually I got it working after a while using something like:

char *CGLabel::GetCaption()
{
return (char*)CGLabel::caption;
} 

Does this return a pointer to a local variable or it actually returns a pointer and sets its value to the value of CGLabel::caption pointer?

[CornedBee]

It does not return a variable local to the accessor, but it may still be unsafe in some certain situations (but to be honest, I've never encountered one before).

[parksie]

Returning it like that is safe as long as you don't try and hold onto it after the object has been destroyed.

[abdul]

Ok, that's good then.

[CornedBee]

I never felt tempted to do that...

[parksie]

Originally posted by CornedBee
I never felt tempted to do that...

Do what?

[Jop]

I think he means:

you don't try and hold onto it after the object has been destroyed.