This is the mail archive of the mailing list for the GDB project.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

Re: [PATCH 1/3] Introduce gdb::unique_ptr

On 2016-10-11 14:36, Eli Zaretskii wrote:
First, it's not true that these C++ changes have not been planned.
They've been part of the plan ever since the very beginning.  See
here, step 5 of the original version of the plan I originally
circulated in 2014:

Current version is here:

Note the not-done-yet bullet points in step 8 (step 5 in rev 1).
That's exactly what's going on right now.

Where does it say that we should require C++11?  Or any specific
version of the C++ standard, for that matter?  AFAIR, this was never

I don't think anybody has seriously suggested requiring C++11 any time soon, other than in a very hypothetical formulation. I can see why there are some misunderstanding, especially for those who haven't followed closely the C++ conversion. Let me try to state what I understand from the situation.

C++03 has been around for long enough that we can safely migrate to that (whereas it has value or not is another debate, although I think Pedro showed clearly that it has), without leaving many users behind. C++11 comes with some nice features in its standard library, such as std::unique_ptr. std::unique_ptr has some improvements over the old std::auto_ptr, which was too easy to misuse. However, I think we all agree that C++11 would be a too aggressive change, and will still be for some time.

What Pedro chose to do is to create gdb::unique_ptr, our home-made version of std::unique_ptr. When building with a C++03 compiler, the hand-written version of the code is chosen and it works (see the #if __cplusplus >= 201103). However, it's possible to misuse it, the same way as it was possible to misuse std::auto_ptr (because of missing features in C++03 vs C++11 IIUC). If you happen to build with a C++11 compiler, instead of choosing the hand-written version, gdb::unique_ptr is more or less an alias for std::unique_ptr. So if there is a place in the code that is misusing it, the build will fail and either buildbot or another developer will let us know promptly.

So it's not that the code is built in a way which requires C++11, it's built in a way that if you use C++11, you get the benefits of the newer checking mechanisms, while still being able to build with a C++03 compiler. IMO it's the best of both worlds. Actually, it's the same idea as gnulib, where we fill the gaps of the lacking platforms, rather than choosing a low common denominator.

The warning analogy was perhaps not clearly expressed but I think it was good. Let's say somebody with an old compiler wrote this code:

  void foo()
    int a;

    global = a;

The old compiler doesn't have a warning to tell you that "a" is being used without being initialized, so it accepts it. When another developer, with a newer compiler, tries to build gdb, he/she gets an error, and is able to report the bug. With unique_ptr, it's similar. Somebody with an old compiler gets less compiler checking. The difference is that we need to write a bit of code (this patch) to bridge the gap, whereas with warnings it comes for free.

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]