Ideas for the upcoming C++0x

The upcoming standard for C++, C++0x, will introduce some interesting new features to C++. I've created a file demonstrating some of my own personal ideas for new features (some of which are already believed to be used in the new standard).

Click here to take a look at the example code.

Remember, almost all of it is just my (probably silly) thoughts, and won't actually be in the new standard.

Discuss.

EDIT:
This is not for real suggestions or anything, just thoughts.

1) The C++0x standard is in its finalization stage. It's a bit late for new feature ideas.
2) Concepts, initializer lists and lambdas are all part of the next standard. Here's an idea of how your example would look there:

Code:

---

#include <iostream>

// This is actually defined by the standard library.
concept Container<typename C>
{
  // Name various types associated with the container (with defaults).
  typename value_type;
  typename pointer = value_type*;
  typename size_type = std::size_t;
  // ...
  typename iterator;
  // A container's iterator must at least model ForwardIterator.
  where ForwardIterator<iterator>;

  // Some members are required.
  size_type C::size() const;
  iterator C::begin();
  iterator C::end();

  // and so on ...
};

template <class T>
class vector
{
    public:
        typedef T value_type;
        // ...

        // Initializer lists aren't finalized yet - no idea how they'll look.
        vector(initializer_list<T> init_list)
        {
            for(int i = 0; i < init_list.length(); i++) // *5
            {
                T curr = init_list[i];
                push_back(curr);
            }
        }

        size_type size() { return m_end - m_start; }
        // ...
};
// Tell the compiler that every vector is a Container.
template <typename T>
concept_map<Container<vector<T>>>
{
  // It should all just fit.
}

template <Container C, UnaryFunction Fn>
  requires Convertible<C::value_type, Fn::argument_type>,
Fn for_each(const C& arry, Fn func)
{
    // Oh yeah, foreach loops are supported.
    for(T &t : arry) {
        func(t);
    }
}

int main()
{
    vector<int> nums = {2, 7, 1, 3, 4, 8};

    for_each(nums, [] (v) { cout << v << endl; });

    // The type of "[] (v) { cout << v << endl; }" is unspecified, but it fulfills the UnaryFunction
    // concept and is thus callable.
}

---

So ... is MinGW going to be updated? Is VC++?

Quote:

---

Originally Posted by guesst

So ... is MinGW going to be updated? Is VC++?

---

Considering that even mainstream compilers still don't offer complete (or at least, completely correct) support for the CURRENT standard, I would wager that full support for C++0x is at least a decade away.

Quote:

---

Originally Posted by guesst

So ... is MinGW going to be updated? Is VC++?

---

Of course. But as Brewbuck says, it's going to take some time before we see the any of the bigger changes [some of the current compiler extensions that for example gcc and VC have are being standardized in the standard, so that will require something from no to very little work to make those features standard compliant], and it may not be complete for MANY years yet. That is, once the standard has be approved - that's yet to happen too...

--
Mats

Some compilers are starting to support TR1, however. It's a start at least.

With respect to those of us in our field who take the time to write the software we use to compile our code; programming languages are like a democracy, everyone is always quick to jump in with complaints and opinions. Hell, even solutions are offered, but ultimately the fact remains, no one ultimately can agree 100% with everyone. I think that is the particular reason why C++ compilers are lagging behind.

Not to mention one simple fact about the software industry that transcends the opinions and complaints of you and me, there will always be rogue companies such as Microsoft releasing compilers that adhere to some areas of the standard, and leaving other areas entirely up to what they think is best. In short, there is far too much chaos for a fully compliant compiler ever to get finished. Especially when software engineers take a liking to non-standard features that their compiler supports.

Work is underway already to support the new standard. Of course, it will still take a long time. But some features are supported.

For example: one compiler has been supporting r-value references for a long time. The standard proposal was mostly based on that feature.
GCC 4.3 (released) has experimental support for quite a few features, like r-value references and variadic templates. GCC 4.4 will have support for more, and GCC 4.5 for yet more.