C++ pointer names

Question

I understand pointers are used to point to objects so you would have to the same around in a program. But were and how are pointer names stored. Would it be an overkill to declare a pointer name that occupies more resource than the object it points to for example:

int intOne = 0;
int *this_pointer_is_pointing_towards_intOne = &intOne;

I know this is a ridiculous example but i was just trying to get the idea across.

Edit: the name of the pointer has to be stored somewhere taking more bytes than the address of the pointed at object.

Answer 1

Microsoft uses the "p" prefix to indicate a pointer:

int intOne = 0;
int* pIntOne = &intOne;

They actually use Hungarian on everything.

It works pretty well once you get used to seeing it. Many people think it is ugly at first.

Whatever you decide, I think it's valuable to denote that something is a pointer type in its name, though I wouldn't go quite so far as your example. :)

Answer 2

The length of the variable name doesn't have any effect on the size of your program, just the length of time it takes to write the program.

Answer 3

Well pointers are most often used for things that are allocated dynamically, and/or functions.

In the case of dynamic allocation, you can just precede it with ptr, if you're insistent on using this notation. In the case of functions, fun works just as well.

Answer 4

Pointer names are not stored. The pointer name (or any variable name for that matter) are not compiled into the final binary (provided you don't compile with symbols set to on).

Pointers are simply integers (or longs) that are stored in memory which, in turn, point to the item they are pointing to in some location in memory.

Answer 5

The name of local variables are only needed for the compiler to find the variables you want to refer to. After compiling, those names usually are erased and completely replaced by numeric symbols or equivalents. This happens for all names that have no linkage practically (of course if you do a debug build, things may be different). So, the same is true for function parameters.

The name of global variables, for example, can't be erased, because you may use it from another unit in your program, and the linker has to be able to look it up. But after your program has been linked, even the name of those can be erased.

And after all, these do not occupy runtime memory. Those names are stored in a reallocation table for the purpose of linking (see the strip program how to remove those names).

But anyway, we are talking about a few bytes which are already wasted by alignment and whatnot. Compare that to the hell-long names of template instantiations. Try out this:

readelf -sW /usr/lib/libboost_*-mt.so  | awk '{ print length($0), $0 }' | sort -n

Answer 6

I agree with previous posts but I would like to point out something around it. Sometimes people overuse pointers thinking that their use will automatically provide small memory footprints. This is not always the case. Consider this piece of code:

void myfunc(const char *var) {
    // Function body
}

A pointer to char will take 4 bytes in a 32 bits architecture while the char itself would usually take 1 byte. (Here var is assumed to point to a single byte, not to a string.) Can you see the point? On the other hand, you should always use pointers (or references) for complex objects:

void myfunc(const string &str) {
    // Function body
}

Of course, in case you want to modify the variable inside your function you should remove the const keyword.

Answer 7

I don't see a reason why it should be preceded with anything at all. Your compiler/editor will do the job for you.