C++ constructor on unnamed object idiom?

Question

I have a C++ class that works like the Linux "devmem" utility for embedded systems. I'll simplify and give an outline of it here:

struct DevMem
{
    DevMem(off_t start, off_t end)
    {
        // map addresses start to end into memory with mmap
    }

    ~DevMem()
    {
        // release mapped memory with munmap
    }

    uint32_t read(off_t address)
    {
        // return the value at mapped address
    }

    void write(off_t address, uint32_t value)
    {
        // write value to mapped address
    }
};

I use it like this:

void WriteConverter(uint32_t value)
{
    off_t base = 0xa0000000;
    DevMem dm(base, base+0x100);  // set up mapping for region

    dm.write(base+0x8, value);    // output value to converter
    dm.write(base+0x0, 1);        // strobe hardware
    while (dm.read(base+0x4))     // wait until done
        ;
}

And this works great. RAII ensures the mapped memory is released when I'm done with it. But some hardware is really simple and only needs a single read or write. It was bothering me that in order to access that hardware, I would have to invent some name for the instantiation of the class:

DevMem whatever(0xa0001000, 0xa0001000);  // map the thing
whatever.write(0xa0001000, 42);           // do the thing

With the named object and the repetition of the address three times, it's a little verbose. So I made a change to the constructor so that I could leave off the end parameter if I'm only mapping a single address:

    DevMem(off_t start, off_t end = 0)
    {
        // map addresses start to end into memory with mmap
    }

And then I overloaded the read and write routines so the address wasn't passed:

    uint32_t read()
    {
        // return the value at the constructor's start address
    }

    void write(uint32_t value)
    {
        // write value to the constructor's start address
    }

And I discovered that I could then do this:

DevMem(0xa0001000).write(42);    // do the thing

And this works. I don't need to invent a name for the object, it's less verbose, the value is written (or read), and RAII cleans it up nicely. What I assume is happening is that C++ is constructing an unnamed object, dereferencing it, using it, and then destructing it.

Is this use of an unnamed object valid? I mean, it compiles okay, GCC and clang don't complain with common warnings cranked up, and it does actually work on the target hardware. I just can't find any examples of such a thing on the Interwebs. Is this a named idiom?

You should either delete the copy constructor+assignment, or implement a proper move constructor+assignment. — HolyBlackCat, Oct 06 '22 at 05:29
FYI: [Temporary objects - when are they created, how do you recognise them in code?](https://stackoverflow.com/a/10898291/7478597) I found it by googling for "c++ working on temporary object" which is how I would call this "technique". (I'm not sure what qualifies something as an _idiom_.) ;-) — Scheff's Cat, Oct 06 '22 at 05:36

score 0 · Accepted Answer · answered Oct 06 '22 at 05:27

Yep, completely valid. You create the object, use it and then the destructor kicks in. Your compiler will probably generate the same assembly in your whatever example if whateverhas a reasonable scope.

I don't know any names for this construct though. As well as I wouldn't call this an idiom.

C++ constructor on unnamed object idiom?

1 Answers1