What modern day characteristics you want to see in C++?

[ad_1]

@qMopey, what do you consider about std::array? It really is just a properly recognized C array, wrapped in a modest issue that adds the length as compile time continuous. Maintaining all the information and facts about the array with each other, as an alternative of obtaining the classic error of utilizing the incorrect size and going out of bounds.

I consider the notion is very good, and the require for an array kind is an essential function missing from C/C++.

If I poke into the header as implemented by MSVC I see some issues that I do not like, which means I do not like how it really is implemented. Which is a distinctive subject than no matter whether or not some thing like std::array is required or could be very good (of course it really is required and could be very good!).

// At the leading off &ltarray&gt header …
#include things like &ltalgorithm&gt
#include things like &ltiterator&gt
#include things like &lttuple&gt

These are quite large headers that pull in other quite large headers, that pull in other quite large headers. This implementation is rather objectively terrible for this explanation alone. All that code, and for what? An array that could be implemented sufficiently in 10 lines of transportable C++.

Yet another qualm I have is how the size of the array is templated and the memory for the array is stored straight inside the array itself. Personally if I have been to implement a templated array I would do it far more like this:

template &lttypename T&gt
struct Array
{
    size_t capacity
    T* information
}

And that is about it. Possibly some comfort member functions for issues like array.commence() and array.finish(), but I would not even implement iterators. Yes, STL has lots of properly implemented and valuable generic algorithms like sorting and whatnot, which make use of iterators, but even so there is practically nothing incorrect with a pointer. array.information + i functions just fine, and generates significantly less templated code compared to iterator implementations (significantly decrease compile instances).

Then there is the query of “what about `Array` vs `ArrayView`”, exactly where Array would be like std::array and retailer components straight, and ArrayView would be like my instance of just a pointer to the underlying information. My argument would be to only have Array, and no by-worth semantics at all. The instance I wrote above can manage all use circumstances just fine. Storing components straight in the array is, in my opinion, far more expressive than required.

In my personal game I use an array, but it really is essentially just a stripped down version of std::vector. The API appears like this.

template
struct array
{
    array()
    explicit array(void* user_allocator_context)
    explicit array(int capacity, void* user_allocator_context)
    ~array()

    T&amp add()
    T&amp add(const T&amp item)
    T&amp insert(int index)
    T&amp insert(int index, const T&amp item)
    void set(int index, const T&amp item)
    void take away(int index)
    T&amp pop()
    void unordered_take away(int index)
    void clear()
    void make certain_capacity(int num_components)
    void steal_from(array&ltT&gt* steal_from_me)

    int capacity() const
    int count() const

    T&amp operator[](int index)
    const T&amp operator[](int index) const

    T* operator+(int index)
    const T* operator+(int index) const

    array&ltT&gt&amp operator=(array&ltT&gt&amp rhs)

    T&amp final()
    const T&amp final() const

    T* information()
    const T* information() const

private:
    int m_capacity =
    int m_count =
    T* m_products = NULL
    void* m_mem_ctx = NULL
}

No require for iterators. Is compatible with std::sort. The only issue it cannot do, that I at times want it could, is to refer to memory elsewhere devoid of attempting to contact `free` upon destruction (like the above `Array` instance). But, I by no means seriously run into this use-case in practice.

[ad_2]

Latest posts