No you can’t. &someVariable is an rvalue. It cannot be assigned to and it is meaningless to try. Furthermore, the very idea of what you are trying to do is meaningless. Function variables are allocated on the stack and are only freed when the function returns. Global variables can’t be freed. Variables within allocated structures … Read more
This dereferences an uninitialized pointer, resulting in UB: *p = i; You probably want this instead: p = &i;
Yes, you can construct a pointer that refers to some arbitrary address in memory, by initialising the pointer with the address directly, instead of with an expression like &a: int* ptr = (int*)0x1234ABCD; // hex for convenience std::cout << *ptr; Be careful, though, as it is rare that you know such a memory address exactly. … Read more
list is one of the many classes provided by the Standard Library. It behaves like any other class type: int : integer int* : pointer to integer Observer : Observer instance Observer* : pointer to Observer instance list<Observer> : list of Observers list<Observer*>* : pointer to list of pointers to Observers
After an object is destroyed, it ceases to exist. There is no point in setting its members to particular values when those values will immediately cease to exist. The pattern of setting pointers to NULL when deleteing the objects they point to is actively harmful and has caused errors in the past. Unless there’s a … Read more
Note that a is not a pointer is an array. So when you subtract a pointer to an another pointer. The result is not really an address, It’s numbers of element between them. The type of the result is ptrdiff_t and you should print it with %td. So when you do &a[1] – &a[0], you … Read more
In your main: char * str2 = “”; and then you pass str2 as a parameter, but it has too little storage and that storage is further read-only memory (points to a literal). The result is your crash. Use: char str2[32] = 0; or any length you need, including a null terminating character.
I follow some simple rules: don’t do manual memory allocations. If you find yourself writing a manual delete, stop and think twice. use std::string instead of C-style strings use std::vector<T> instead of C-arrays (or std::array<T> for fixed-sized arrays) use std::unique_ptr and std::make_unique by default use std::shared_ptr if necessary use RAII wrappers for other resources, e.g. … Read more
An array of arrays like yours look like this in memory +———+———+———+———+———+———+ | x[0][0] | x[0][1] | x[0][2] | x[1][0] | x[1][1] | x[1][2] | +———+———+———+———+———+———+ The location of x, x[0] and x[0][0] is all the same. Also, arrays naturally decays to pointers to their first element. If you use plain x you will get … Read more
That is to consider an integer value as a pointer (expecting to access the memory pointed out by that integer value), nothing else. However, this is not a very good practice. Quoting the C11, chapter ยง6.3.2.3 An integer may be converted to any pointer type. Except as previously specified, the result is implementation-defined, might not … Read more