how to declair a pointer at a memory location and a initilize it with a value

Question

when I run this code I get a segmentation fault and I understand why I get it it is because I did not use the new initializer to allocate space for it. How do I do what I am trying to do? you should be able to see what I am doing by looking at my code, but in case you can't tell. I am trying to declare a pointer to a specific address and then pass a value to that address. here is my code:

#include <iostream>
using namespace std;

int main(){


    double *ptr;
    ptr= (double*) 0x7fff07814c28;
    *ptr= 77.9;
    cout<< "pointer value \n";
    cout<< ptr;
    cout<< "\n";
    cout<< "value pointed to by pointer \n";
    cout<< *ptr;
    cout<< "\n";

    }

Answer 1

how to declair a pointer ....

You can declare a pointer (to double) like this:

double* ptr;

... at a memory location ...

You can initialise the pointer with a memory location:

double* ptr = some_address;

Or assign it after declaration:

ptr = some_another_address;

and a initilize it with a value

There are a few ways to acquire storage for objects:

• You can acquire static, thread static and local storage by defining variables. As an example, the storage for the pointer variable ptr was allocated like this - not to be confused with the storage that the pointer points to.
• You can acquire dynamic storage using a(n allocating) new expression (or the std::malloc family of functions from the C standard library).

Neither of these options let you specify the memory address where the storage should be placed. There is no way in standard C++ to request storage for a variable from an arbitrary address.

---

when I run this code I get a segmentation fault

The reason from perspective of C++: You indirect through a pointer that doesn't point to an object. The behaviour of your program is undefined.

The reason from perspective of your operating system: The process attempted to write into a virtual address that was not mapped, or was marked protected or read only, and so the operating system raised a signal and terminated the process.

---

Now, if and only if the C++ implementation that you use gives you a guarantee that some arbitrary memory location may be used for storage, then you can use placement-new expression to create an object in that memory location. An example of such situation is mmap call on a POSIX system. Here is an example how to create an object in such storage:

// let there be storage at some memory address
// let the amount of storage, and alignment of the address be sufficient for T
char* storage = some_special_address;

// create an object into the storage
T* tptr = new(storage) T;

// after you're done using the object, destroy it:
tptr->~T();
// after destruction, the storage can be released, if needed and if possible

How do I do what I am trying to do?

Run your program on a system that doesn't use virtual memory (i.e. on a system that does not have an operating system). Then consult the manual of that system for what memory addresses you can use. Then see the previous example about how to create objects in the storage that you control. Make sure that the address satisfies the alignment requirement of the object that you create.

Answer 2

Accessing specific address in the memory space depends on the platform and the operating system.

On many desktop systems (e.g. Windows & Linux), the OS grants your program permission to access a portion of memory. Any access beyond those limits will cause a segmentation fault or other error. You'll have to have kernel permission to access specific areas in memory provided that there is memory in that address range.

On embedded systems, pointers are assigned to specific addresses, to access memory and hardware devices. Also depends on if the OS (if there is one) grants you privilege to access those devices. Also, be prepared for undefined behavior when you access undefined addresses or address that have nothing associated with them. (On many embedded systems, the addressing space is decoded for various purposes, such as USB controller. If the address is not decode, undefined behavior will rear its ugly head.)

Before you access a random location, verify that there is something there and that you have permission to access it.

Search the internet for "Operating system virtual memory".

Answer 3

 ptr= (double*) 0x7fff07814c28;

This has no meaning. In modern OSes, memory operation is not real mode so you cannot directly address it.

Memory is not a C array (e.g. if you have 4GB, you can't do unsigned long m[0] to address the first byte).

Memory is managed by the CPU in various modes (protected, long are the standard) and therefore, you cannot know the "exact" array location.

In short, use new[], or even better, STL.