Pascal figures in this in that the official standard Pascal was basically unworkable as a language, due to features like the size of an array being an obligatory part of its type and the resulting lack of a way to write a function that could handle more than one size of array. Having it be optional, as we see here in C, is really the only way to go unless an array knows its own size and won't let you overstep the bounds.
If only this was true
http://blog.llvm.org/2011/05/what-every-c-programmer-should-...
I had to develop with multiple C commercial compilers between 1999 and 2002, across several OS. The code had quite a few #ifdefs because of them.
Are you aware that C11 has optional features?
> Pascal figures in this in that the official standard Pascal was basically unworkable as a language, due to features like the size of an array being an obligatory part of its type and the resulting lack of a way to write a function that could handle more than one size of array. Having it be optional, as we see here in C, is really the only way to go unless an array knows its own size and won't let you overstep the bounds.
The first ISO standard yes, but all Pascal dialects always had feature parity with C, while being more type safe, fast compile times and direct support for modules.
Most of it was made part of the ISO Extended Pascal standard, which most people ignored as the industry cared more about Turbo Pascal compatibility. Both solve your arrays example.
The common complaint that the stronger type checking languages impose performance penalty with arrays bound checking is always wrong, as the compilers allow for it to be turned off.
In both cases it is the problem with standards and vendor differentiation, you seldom get a 100% compliant implementation of any standard.
The advantage of C++ was always that it enabled (slightly) more rapid development than C.
- all pointer access done via smart pointers
- std::vector instead of native arrays
- Use std::vector::at() instead of std::vector::operator[]() unless profiling shows a relevant performance increase
- std:string instead of char*
- References instead of pointers for mutable parameters
If you do C like coding in C++, which is of course possible, then C++'s safety over C gets thrown out of the window.
When I get to decide, the continuous integration build is always done with all warnings enabled, warnings as errors and static analyzers tools.
The developers can do the local build as they prefer, though.
Me too, my first C++ compiler was Turbo C++ 1.0.
They are a lot safe than using the C direct pointer manipulation idioms that make it so easy to create insecure code that can explode at any moment.
What STL offers might not be 100% as safe as the Pascal family of languages offer among others, but it sure is a way lot better than using plain C idioms.
The problems you describe are quite easy to spot if a static analyzer is made part of the build.
Personally I would rather use another language in the Pascal family (Turbo Pascal refugee), but it is not always possible to choose.