通过指针访问char *

Question

here is my problem.

I have a class that regularly modifies a char*.

There is another class, that needs to be able to read this value. So I want to pass the char* to the constructor of this second class, so that it can check the value, when required.

Let me give an example of the implementation that I have for another parameter, it is of a type boolean:

In ClassA:

bool f_valid = false; // global

m_eventCatcher.addProxy(porting::shared_ptr<CallbackProxy>(new handleCall(&f_valid))); 

In ClassB:

struct handleCall 
{
    bool* m_dataValid;

    handleCall(bool* result) 
    {
        // saving the pointer to the boolean that I want to change
        m_dataValid = result; 
    }

    method()
    {
        if (smth) 
        { 
            (*m_dataValid) = false;
        }
    }
};

So far so good - this seems to work. Both classes can change and access this boolean.

Now I need to do the same thing with a char* (I cannot use string, so I guess this is a best way to store a short text, like a url address?).

So here is what I wrote:

ClassA:

const char* f_url = "blah blah"; // global

m_eventCatcher.addProxy(porting::shared_ptr<CallbackProxy>(new handleCall2(&f_url)));

ClassC:

struct handleCall2 
{
    char ** m_url;

    handleCall2(char** url)
    {
        // saving the pointer to the char*
        m_url= url;
        std::cout << (*m_url) << std::endl; // prints out url fine
    }

    method() 
   {
        std::cout << (*m_url) << std::endl; // by this time the value has been changed by ClassA, and I print out some rubbish - symbols, squares, etc.
    }
};

I guess the problem is because the string has changed, its' address has changed too? I am getting really confused - can someone tell me what is going on, and what should I do in this situation?

UPDATE:

Looks like the problem is in HOW I modify the char*:

f_url = "new text"; // works fine

f_url = fileUrl.c_str(); // doesn't work! I get rubbish in the value when I try to access it from ClassB

strcpy(m_url, fileUrl.c_str()); // I also removed const from the variable and tried this - got a crash "access violation using location" :(

Is there any other way of writing the value of a string into a char *?

Answer 1

const char* f_url = "blah blah";

this declaration means that you have a pointer to a constant string. So you can't do

strcpy(f_url, "hello world"); // copy to the preallocated place

but you can

f_url = "hello world"; // do pointer assignment

If you have next situation :

class ClassA {
const char* f_url = "blah blah";
public: 
    void method() {
        f_url = "hello world";
    }
};

class ClassB {
    char** m_url;
public:
    void print() {
        cout << (* m_url); // m_url points to a string, allocated on the stack of ClassA::method()
    }
};

keep in mind that string "hello world" is allocated on the stack of the ClassA::method() . And that pointer is no longer valid when the ClassA::method() quits. to solve the issue I propose next:

class ClassA {
static const int max_path = 256; 
char f_url[max_path];
public: 
    void method() {
        strcpy(f_url, "hello world");
    }
};

class ClassB {
    char** m_url;
public:
    void print() {
        cout << (* m_url);
    }
};

Answer 2

I do not see any problem with accessing a char * .

I wrote a sample code and it worked for me. May be yours is a different issue:

BTW here is my code for your reference:

#include <iostream>

class ClassThatPrints
{
private:
    const char **m_url;

public:
    ClassThatPrints(const char ** url)
    {
        m_url = url;
        std::cout << (*m_url) << std::endl;
    }

    void PrintAfterModify(void)
    {
        std::cout << (*m_url) << std::endl;
    }
};

class ClassThatModifies
{
private:
    const char *m_charPointer;
    ClassThatPrints *m_ClassThatPrints;
public:
    ClassThatModifies()
    {
        m_charPointer = "this is the original string";
        std::cout << "Printing before modification:" << std::endl;
        m_ClassThatPrints = new ClassThatPrints(&m_charPointer);
    }

    ~ClassThatModifies() {
        delete m_ClassThatPrints;
    }

    void ModifyStringAndPrint(void)
    {
        m_charPointer = "this is a modified string";
        std::cout << "Printing after modification:" << std::endl;
        m_ClassThatPrints->PrintAfterModify();
    }
};

int main()
{
    ClassThatModifies objClassThatModifies;
    objClassThatModifies.ModifyStringAndPrint();

}

Answer 3

If you have something like this:

void addHandler() {
    const char* f_url = "blah blah";
    m_eventCatcher.addProxy(porting::shared_ptr<CallbackProxy>(new handleCall2(&f_url)));
}

void doStuff() {
    addHandler();
    m_eventCatcher.callProxy();
}

then the problem is that f_url is out of scope when addHandler returns. If this is the case, then your bool version also had the problem, and (*m_dataValid) = false; overwrote some other data.

Answer 4

const char* f_url = "blah blah"; // global

Maybe you misunderstand this line? The const qualifier is when you are placing it, referring to the keyword left of it. It's allowed to take it as first keyword but then, AND ONLY then, it is referring to its right ;) So your declaration says: (const char) *f_url so its an pointer to an const char. And I'm guessing (I don't know what's the way you are modifying it's value in that class) you get it by your self, why modifying a const char value could end in rubbish output, don't you? I suggest you want to declare it as

char *const f_url = "blah blah";

this is

char (* const) f_url

so f_url is an constant address-value which is pointing into an modifiable area. But even this wouldn't make that much sense, because "blah blah" is a address of a const memory area, so you cant modify ("blah blah")[count] = Anything; anyway.

So you should just do

char *const f_url = ThisIsACharArray[count];

and access the char array aka String about f_url.

Or the better way for you, as I would guess, just keep the const out of the declaration and allocate modifiable memory by your self ;)

Answer 5

The string is not actually stored in f_url . The string is stored somewhere else , and f_url is a pointer to that somewhere else .

If you do this:

    f_url = "new text"; // works fine

When your program is compiled it will include the string "new text" somewhere in it. f_url will point to that - to some memory in the middle of the program itself.

    f_url = fileUrl.c_str(); // doesn't work! I get rubbish in the value when I try to access it from ClassB

fileUrl is a std::string. fileUrl has its own pointer to a string, which c_str returns. Since fileUrl is in responsible for managing this string, when fileUrl goes out of scope the memory may be reused for something else - it doesn't know you were still using that memory.

    // I assume you meant f_url here, not m_url
    strcpy(f_url, fileUrl.c_str()); // I also removed const from the variable and tried this - got a crash "access violation using location" :(

What this does depends on what f_url is actually pointing to. If f_url is pointing to some memory in the middle of your program (as with f_url = "blah blah"; ) then this will crash. Normally, this indicates a bug, so the operating system will not allow you to do it.

If it was allowed, this could happen:

char *s = "hello world";
strcpy(s, "abracadabra");

printf("hello world"); // prints "abracadabra"

What you need to do is get your own block of memory to hold the string, and free it when you are done:

f_url = new char[fileUrl.length() + 1];
strcpy(f_url, fileUrl.c_str());

// when you don't need the string any more
delete [] f_url;

or:

f_url = strdup(fileUrl.c_str());

// when you don't need the string any more
free(f_url);

or just make f_url a std::string which handles memory management for you. (This is the easiest solution!)