Accessing a char* through a pointer

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 *?

Oh, and another thing: [`std::string`](http://en.cppreference.com/w/cpp/string/basic_string) is much better at handling strings than raw pointers. — Some programmer dude, Aug 09 '13 at 11:16
Strings are allocated in the .rdata section of the file during compile time. Modifying them might cause to overwrite other data. Use `std::string` instead. — Levente Kurusa, Aug 09 '13 at 11:17
*"Now I need to do the same thing with a `char*` (**I cannot use string**, [...])."*. However, I wonder why you cannot use `std::string`. — Zeta, Aug 09 '13 at 11:18
What C++ compiler are you using that is *not* screaming warnings/errors at you about sending addr-of `const char *` and storing it in a `char **` ?? — WhozCraig, Aug 09 '13 at 11:21
Does the ClassA function return before the variable is changed? — user253751, Aug 09 '13 at 11:22
If you can't use `std::string`, then how about `std::vector`? Yes a vector is fully capable of holding a string, it just can't do "stringy" operations easily, but still probably better than raw pointers. — Some programmer dude, Aug 09 '13 at 11:23
Those aren't classes, they're structs. It seems perhaps you have C code rather than C++? — SD1990, Aug 09 '13 at 11:46
In C++, structs are classes where members are public by default. — user253751, Aug 09 '13 at 12:27
I cannot use std library all together (apart from for temporary logging), as the project will later be recompiled without std. — Monday to Friday, Aug 09 '13 at 12:50
@WhozCraig I am using normal VS12 compiler and gcc - seems to be compiling fine :) — Monday to Friday, Aug 09 '13 at 12:50
@Joachim Pileborg btw its also tagged as c question, so maybe not everyone is able to use std::string or std::vector or even anything of STL hm?;) — dhein, Aug 12 '13 at 11:40
@Zaibis In that case the OP maybe shouldn't have tagged it C++? — Some programmer dude, Aug 12 '13 at 11:49

Nikita · Answer 1 · 2013-08-09T12:34:22.607

0

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);
    }
};

edited Aug 09 '13 at 12:34

answered Aug 09 '13 at 12:00

Nikita

950
8
19

I am not using strcpy – Monday to Friday Aug 09 '13 at 12:49
grrr pressed enter too early again. So how do you propose to send char[] to ClassB and how to store it in a char**?... – Monday to Friday Aug 09 '13 at 13:34
just reuse the code you already have. char[] is the same as char*. – Nikita Aug 09 '13 at 13:53
when I try to pass f_url (which is char f_url[256]) into a function that expects const char** (new handler(&f_url);), I get a compilation error: 'cannot convert parameter 3 from 'char (*)[256]' to 'const char **' – Monday to Friday Aug 09 '13 at 14:04
if you don't change the f_url pointer, then you may just pass char* to new_handler constructor. and store the pointer as m_url in the ClassB. – Nikita Aug 09 '13 at 15:23
@user2199745 Well if you have char f_url[256] then is f_url the adress of the first element. NOT a pointer to the first element. And you can't say something like this &(&int var) because a adress has no adress. You would have to do char *ptr; ptr = f_url; and pass into function: &ptr – dhein Aug 10 '13 at 13:59

score 0 · Answer 2 · answered Aug 09 '13 at 12:12

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();

}

you are right - this does work! I was doing everything right then, the problem must be somewhere else... — Monday to Friday, Aug 09 '13 at 12:48
Well but this code differs from what is explained in the Question. He said hes modifing the value of the pointer, you just asigned a new pointer in your "modifi method" thats a big difference, you'r modifing is a legal operation, while modifing the value of the chars at that adress (Thats what his explanation did sound like for me) is absolutly incorrect. — dhein, Aug 10 '13 at 01:46

score 0 · Answer 3 · answered Aug 09 '13 at 12:31

0

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.

answered Aug 09 '13 at 12:31

user253751

57,427
7
48
90

no, f_url and the bool are not going out of scope - they are defined inside the class outside of all the methods. – Monday to Friday Aug 09 '13 at 12:34

score 0 · Answer 4 · answered Aug 10 '13 at 01:39

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 ;)

score 0 · Answer 5 · answered Nov 19 '13 at 08:12

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!)

Accessing a char* through a pointer

5 Answers5