How can I initialize an attribute without knowing which constructors he has?

Question

I need to implement the following class :

template <class Element, class Compare = std::equal_to<Element>>
class UniqueArray {
    Element* data;
    unsigned int size;
    unsigned int max_size;
public:
    explicit UniqueArray(unsigned int size);
    UniqueArray(const UniqueArray& other);
    ~UniqueArray();
    UniqueArray& operator=(const UniqueArray&) = delete;
    unsigned int insert(const Element& element);
    bool getIndex(const Element& element, unsigned int& index) const;
    const Element* operator[] (const Element& element) const;
    bool remove(const Element& element);
    unsigned int getCount() const;
    unsigned int getSize() const;
};

The problem is I can't assume that Element has a defualt constructor. Assuming I can't see the implementation of Element class meaning that there might be other constructors but I don't know how much parameters there are and what are their types. How can I initialize the data attribute of UniqueArray?

For example Element can be a Point which has a constuctor with two arguments(and no defualt constructor) But the point is I don't know which element is being sent and I don't know what constructor this Element has. The code supposed to be generic.

... or `std::set` if the elements are supposed to be unique? — 463035818_is_not_an_ai, Jan 06 '20 at 11:21
reinventing a wheel aside, I dont really understand the question. Why do you want to create objects when you do not know how? Only when `insert` is called you need to insert an `Element` and there you just need to copy not call a constructor — 463035818_is_not_an_ai, Jan 06 '20 at 11:23
taking the question literally, you can initialize `data` with `nullptr`, but I doubt that is what you want to hear. Can you try to clarify the question? Maybe add a piece of code where you would have to call the constructor but cannot (i dont see where that would be the case) — 463035818_is_not_an_ai, Jan 06 '20 at 11:26
I'm not allowed to use STL in this part (its part of a Uni hw). I will edit the post and try to make things more clear. — Eliran Turgeman, Jan 06 '20 at 11:37
Allocate raw memory with the proper alignment, create objects as needed with placement new. (This is what `std::vector` does.) — molbdnilo, Jan 06 '20 at 11:39
Off topic, but the `operator[]` has a very peculiar prototype. And what is the difference between `getCount` and `getSize`? — molbdnilo, Jan 06 '20 at 11:41
Practically, you can’t create any objects, because there are no non-copy constructors. — asmmo, Jan 06 '20 at 11:42
You say you're not allowed to use the standard library, but you use `std::equal_to`. Are you allowed to use `std::allocator`? — Timo, Jan 06 '20 at 11:42
@molbdnilo getCount returns the current size . getSize returns the max size. As for the peculiar prototype i'm not responsible for it nor I can change it. (uni hw) — Eliran Turgeman, Jan 06 '20 at 11:42
@Timo ```std:equal_to``` is the only thing I can use from the standard library — Eliran Turgeman, Jan 06 '20 at 11:43
Have you had a previous assignment to implement `::vector`? Can you use that? — Caleth, Jan 06 '20 at 13:16

rustyx · Answer 1 · 2020-01-06T12:28:56.373

It's unclear what the constructor UniqueArray(unsigned int size) is supposed to do - default-construct that many elements or reserve storage?

If it only reserves storage, then you could use std::aligned_storage to decouple storage allocation from object construction, and let the user of UniqueArray create the elements:

template <class Element, class Compare = std::equal_to<Element>>
class UniqueArray {
    using storage_type = typename std::aligned_storage<sizeof(Element), alignof(Element)>::type;
    storage_type* data;
    unsigned int size;
    unsigned int max_size;
public:
    explicit UniqueArray(unsigned int size) : size(0), max_size(size) {
        data = new storage_type[size];
    }
    ~UniqueArray() {
        for (unsigned pos = 0; pos < size; ++pos) {
            // note: needs std::launder as of C++17
            reinterpret_cast<Element*>(&data[pos])->~Element();
        }
        delete[] data;
    }
    Element& operator[](unsigned pos) {
        // note: needs std::launder as of C++17
        return *reinterpret_cast<Element*>(&data[pos]);
    }
    void insert(const Element& element) {
        new (&(*this)[size++]) Element(element); // placement-new
    }
    // ...
};

struct A {
    int a, b;
    A(int x) : a(x), b(x + 5) {}
};
int main() {
    UniqueArray<A> arr(3);
    arr.insert({ 2 });
    std::cout << arr[0].b << std::endl; // prints "7"
}

I'm not allowed to use STL besides ```std::equal_to```. The constructor ```UniqueArray(unsigned int size)``` should initialize all attributes — Eliran Turgeman, Jan 06 '20 at 11:50
@EliranTurgeman What is an "attribute" in this context? Do you mean "member variable"? — Martin Bonner supports Monica, Jan 06 '20 at 11:53
In that case you need to provide some kind of factory class (or in C++ terms, an allocator) that knows how to default-construct elements. — rustyx, Jan 06 '20 at 12:35

Daniel Jour · Answer 2 · 2020-01-06T14:41:04.043

First, gathering requirements:

"std:equal_to is the only thing I can use from the standard library"
There's a max_size and a size member, getCount() returns the current size and getSize() the max size (side note: this is horrible ...)

So I'd assume that the constructor of your class should allocate enough memory to hold size (the parameter) objects of the Element class.

The proper way to do this would be - as suggested in rustyx' answer - to use std::aligned_storage. Since this is for a university homework and your lecturer / professor / person who wrote this assignment probably doesn't know enough about C++ to care / understand the issues you probably are best of with something like this:

// in constructor, I repeat, THIS IS HORRIBLE!
max_size = size; // better use member initialization, though
data = reinterpret_cast<Element*>(new unsigned char[sizeof(Element) * max_size]);

When inserting you use placement new to create a new element as a copy:

new (data[index_for_new_element]) Element(element);

For erasing you need to call the destructor manually!

data[index_to_erase].~Element();

I repeat: This is not how you'd write such code in a real application! It does not teach you anything valuable!

score 0 · Answer 3 · answered Jan 06 '20 at 14:14

0

After a discussion with a tutor this is the way to go about it :

data member variable will be initialized to an array of null pointers. each pointer points to an Element.

We can assume that there is a copy constructor. Whenever we want to insert a new element to the array we call insert() and this function inserts a copy of the element it got as an argument.

answered Jan 06 '20 at 14:14

Eliran Turgeman

1,526
2
16
34

Also this doesn't look like an answer .. please add additional info to your question. – Daniel Jour Jan 06 '20 at 14:42
Will do, got any particular advice on which book ? – Eliran Turgeman Jan 06 '20 at 14:47
Can only link to this list: https://stackoverflow.com/q/388242/1116364 – Daniel Jour Jan 06 '20 at 21:49

How can I initialize an attribute without knowing which constructors he has?

3 Answers3