How to store a variable or object on desired memory location?

Question

Let's suppose I have an object of a class as shown below:

Myclass obj;

Now I want to store this object to my desired memory location. How can I do this? Is it possible or not?

I have created an array class which simply insert data of integer type in respective indexes but the size of array is not declared inside the class. I insert small amount of data like 50 to 60 integers , then I use loop to insert a large data inside this class, but this time my program crashes , I think it is because of reason that if some index is encountered in memory which has some value in it , program stops itself. Now I want to analyze the memory that my object of array class start from that particular address which contain maximum number of available empty useable memory spaces

I think it is not allowing more insertions because of some allocated memory location. Now I want to place my object on that memory address which contain maximum available empty useable space. Please guide me

#include<iostream>
using namespace std;

class newarray 
{
public:
    int n;
    int arr[]; //size not declared 
    int* ptr;

    newarray():n(0),ptr(NULL)
    {
    }

    void getadress(int indexno) //for getting address of an index
    {
        ptr=&arr[indexno];
        cout<<endl<<ptr;
    }

    void insert(int a) //inserting an element
    {
        arr[n]=a;
        n++;
    }

    void display()
    {
        for(int i=0;i<=n;i++)
        {
            cout<<endl<<arr[i];
        }
    }
};

int main()
{
    newarray a1;
    int x=1;

    for(int i=0;i<100;i++) //work good with 100 inssertions
    //but if exceed to 300 or more it crashes.
    {
        a1.insert(x);
        x++;
    }
    a1.display();
}

Answer 1

You can initialize an object to a specific memory location by using the new operator with a memory address like so:

MyObject *obj = new(address) MyObject(arguments);

Note that when using "new" like this, you will probably need to call the destructor manually to run its logic.

Answer 2

In case of a variable, you never have an option to choose the memory location. The language implementation takes care of that for you, and in ideal cases might even not use any memory at all.

In case of dynamic objects, it is possible to create an object in a memory location of your choice - but there are limitations: On memory mapped systems (i.e. any modern operating system), you are restricted to only use memory that you have allocated. You generally cannot choose the memory addresses where allocations are, but you get to choose within the allocation, where to create dynamic objects - so long as the address satisfies the alignment requirements of the type. There are many ways of allocating memory, provided both by the C++ standard and by the operating system.

---

An embedded system might be one where memory isn't mapped. There, you don't have an operating system from which you could or would need to allocate memory.

On such system, if you are in control of the hardware, you will know which memory addresses in which you can safely create objects by virtue of knowing how you set up the hardware. If you don't know how the hardware is set up, then you must read the documentation.

Answer 3

You can't choose an arbitrary address in memory-mapped systems and store an object there. You need to first allocate a buffer (for example using new[]) and then construct your object in that pre-allocated buffer using placement new.

Here is a simple example:

#include <iostream>
#include <cstddef>


class Myclass
{
public:
    int m_value;
};

int main( )
{
    std::byte* buffer  = new std::byte [ sizeof( Myclass ) ]; // allocate a buffer
    Myclass* ptr = new ( buffer ) Myclass( 123 ); // construct the object in
                                                  // that buffer

    std::cout << ptr->m_value << '\n'; // print the value for
                                       // demonstartion purposes

    ptr->~Myclass( ); // explicitly call the destructor
    delete [ ] buffer; // release the buffer
}

Now back to the bug in your code. The problem is that your arr does not have a fixed size. That's not good. Instead of that use a std::vector so that it can extend itself at run-time by inserting elements at its back.

Here is the fixed version of your program:

#include <iostream>
#include <vector>


class NewArray
{
public:
    NewArray( )
    : arr( 0 )
    {
    }

    void getAddress( const std::size_t idx ) // for getting address of an index
    {
        std::cout << '\n' << &arr[ idx ];
    }

    void insert( const int elem ) // inserting an element
    {
        arr.push_back( elem );
    }

    void display( )
    {
        for( const auto& elem : arr )
        {
            std::cout << '\n' << elem;
        }
    }

private:
    std::vector<int> arr;
};

int main( )
{
    NewArray a1;
    int num { 1 };

    for ( std::size_t i { }; i < 100; ++i )
    {
        a1.insert( num );
        ++num;
    }

    a1.display( );
}

Answer 4

You wrote

 class newarray 
    {
    int arr[]; //size not declared

This is not allowed. Unfortunately, your compiler did not warn you when compilinhg. You only discovered that this was a problem when your code crashed.

You then wonder about "some allocated memory location" and picking one manually. That's not the problem. int arr[] without explicitly specifying bounds is allowed only in a few contexts, such as a function declaration. The function declaration doesn't need a size because the size in that case is determined by the caller.

Since this is C++, just use std::vector<int> for your dynamic arrays.

Answer 5

Objects have a unique memory adress. Once the object exists you cannot change where it is stored in memory. You can create a copy and store that copy elsewhere, but you cannot store that particular object in some other memory adress after it has been created.