Converting string to pointer

[Ch1156]

I was wondering how do i convert this string to pointer

#include <iostream>
#include <string>
#include "_Header.h"

using namespace std;

void passbyreference(int *x, int *z)
{
    *x = 66;
    *z = 900;
}

void strfunction(string *S)
{
    *S = "fdsfs";
}

int main()
{
    int sandy = 13;
    int int2 = 0;
    string *str;

    passbyreference(&sandy, &int2);
    strfunction(&str);

    cout << sandy << " " << int2 << " " << str << endl;

    return 0;
}

[Lowest0ne]

You never actually make a string, change line 22 to string str, and things should work out.

[Ch1156]

ah i see, so how does the pointer know that str is a pointer if i dont put * in front of it? Is it because of the ampersand operator?

[S6k9GNh0]

I'm not understanding the question. The ampersand obtains the "location" or pointer to that variable. You cannot take any type, outside of pointers, and randomly turn into a pointer, C++ doesn't allow this. You can only cast a pointer into another pointer.

I would suggest just passing the string by reference. If you're interacting with a C API, you can use c_str() and size(), create your own array type, or use whatever the C API lets you use.

[Ch1156]

Im tryingf to use C++, i know that the pointer is a memory address and the & sign i believe is a direct copy of the variable. am i right? What i want to know is what im doing is getting the memory address of the string or ariable and then the & symbol gets whats inside of it?

[S6k9GNh0]

Again, I'm not sure I understand. The ampersand isn't a copy of the variable, it's a copy of the location of the variable (the pointer to the variable).

[Ch1156]

right and thats what im saying, so i made a pointer to str which is

*S = "String #1";

if i just outputted S it would give me a hexidecimal value of where its stored, but doing strfunction(&str, &str2); its assigning a copy of the string "String #1" to str therefore when i go to output it in main, the output is not the hex value but String #1, do you understand now? is that what is happening ingthe code?

[S6k9GNh0]

No because the pointer doesn't point to anything as of yet. Initializing a pointer doesn't initialize or allocate memory. It only allocates the size of one pointer (generally 2/4/8 bytes) which is what you're asking for.

std::string *pString;

This only creates a pointer which contains virtual type data, not a string.

std::string myString;

This creates a string. You can fetch its pointer by using the ampersand.

Also, in your above example, you're actually giving a pointer to a pointer. The type you're passing is actually std::string**, not std::string*.

NOTE: The only exception to this is C strings.

const char* pString = "This is a test example";

This is rather anti-intuitive... but it allocates an array on the stack just large enough for the array + 1 (which its allowd to do since the string must be a constant literal) where the last element contains a null character. I will never suggest you do this no matter how much C I use. Null terminated strings are pretty laughable outside of when you have to iterate through every single character anyways.

[Ch1156]

Ok so now im back to being confused as hell again. But maybe i understand, so the * and the & are both pointers?

[S6k9GNh0]

int variable; //Basic variable
int *pVariable; //Uninitialized pointer
pVariable = &variable; //pVariable now points to variable


int test = 10;
int *pTest  = &test;
variable = *pTest; //This "dereferences" pTest to fetch the data pTest points to
//variable is now equal to test



int & rVariable = variable; //reference to a variable but isn't a variable
int *&rpVariable = pVariable; //Reference to a pointer but isn't a pointer 

[Ch1156]

ok the middle part is what i was trying to do. What exactly does "dereferencing" do?

[Ch1156]

Ok i watched some tutorials and i think i understand better, the guy explained it like i had no common sense which helped a ton

#include <iostream>
#include <string>

using namespace std;

int main()
{
    int x = 70;
    int *ptr;

    ptr = &x;

    cout << *ptr << endl;
}

ok so int x = 70; and i made a pointer *ptr, then i assigned the memory address of x to ptr then de refernced it so i could see the contents of x? thats kind of like what you had pretty much, but the thing is i have to see it and it has to be explained in exactly the right way or i wont understand it. but am i right so far? how do i do that same thing with a function?

im confused here

#include <iostream>
#include <string>
#include "Test.h"

using namespace std;

void function(int &A)
{
    int test = 9000;
    int *pTest;

    pTest = &test;
}

int main()
{
    int x = 70;
    int *ptr;

    ptr = &x;

    cout << *ptr << endl;
    cout << function() << endl;


}

[MrHutch]

What exactly are you wanting the function to do?

[Ch1156]

ok i want to get test from the function, and de reference it in main and output it to get 9000

[MrHutch]

So you want to return the address of a local variable? It's doable, but dangerous in my opinion. I wouldn't ever think of doing it.

Nevertheless, here's how it can be done.

#include <iostream>

int* SomeFunc()
{
   int x = 9000;
   return &x;
}

int main( int argc, char* argv[] )
{
   int *intPtr;

   intPtr = SomeFunc();

   std::cout << "Pointing to " << *intPtr << " at " << intPtr << std::endl;
}

[Ch1156]

Thanks, why is it dangerous? also why dont i need the & operator in front of the function name?

int *pointer2 = function();

like i do this

int *pointer1 = &x;

??

[MrHutch]

Ch1156 wrote:

Thanks, why is it dangerous?

Myriad reasons, really. C++ isn't really a memory safe language. You're given a lot of responsibility in that respect. When the function is popped from the stack, so too are the local variables. Implementations aren't guaranteed to preserve that data. It could, for example, be overwritten with some arbitrary value, like zero. Or perhaps the memory location is no longer mapped into memory.

In any event, you're setting yourself up for a world of hurt. There's a reason the compiler spits out a warning.

Ch1156 wrote:

also why dont i need the & operator in front of the function name?

The function returns a pointer to an integer, i.e. a memory location that points to an integer type. Locally, we've declared our local intPtr as a pointer to an integer. As these two match, there's no need for a reference operator.

[Ch1156]

Ok thanks for the info, is there any way i can work with memeory safely? or learn how to use pointers safely so nothing bad happens?

[MrHutch]

If you Google it, there'll be a ton of articles and posts on the safe use of pointers.

The main thing is just to be careful. Keep an eye on scope. If you use the heap, make sure you delete properly and use deep copying where necessary.

[Ch1156]

Ok i'll google all that stuff here in a minute. But i need to delete pointers? i though you only used the delete keyword when you use new?