This is the mail archive of the
mailing list for the GDB project.
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
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:
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.