- \n
- Windows using Visual Studio 2015<\/li>\n
- Windows using Visual Studio 2017<\/li>\n
- GNU\/Linux using Clang\/LLVM 3.6<\/li>\n
- GNU\/Linux using GCC 5.1<\/li>\n<\/ul>\n
But that is not all; there exist more implementations on GitHub. I want explicitly emphasize the GSL-lite <\/a>implementation of Martin Moene. His implementation even works with C++98 and C++03.<\/p>\n
Before I dive into the details, there is one issue that makes my writing difficult: the lack of good documentation or tutorials. To get an idea, of what the function and types should support, you have to install the library and analyze the unit test. That is not the kind of documentation I expect. In contrast, installing and using Microsoft’s implementation of the GSL was relatively easy on Windows and Linux.<\/p>\n
<\/p>\n
![\"support\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/07\/support.png\")
<\/p>\nSo, let me dive into the details. The GSL consists of five components. Here is a first overview:<\/p>\n
- \n
- GSL.view: Views<\/a>\n
- \n
- span<T><\/span><\/li>\n
- string_span<T><\/span><\/li>\n
- (cw)zstring<\/span><\/li>\n<\/ul>\n<\/li>\n
- GSL.owner<\/a>\n
- \n
- owner<T><\/span><\/li>\n
- unique_ptr<T><\/span><\/li>\n
- shared_ptr<T><\/span><\/li>\n<\/ul>\n<\/li>\n
- GSL.assert: Assertions<\/a>\n
- \n
- Expects()<\/span><\/li>\n
- Ensures()<\/span><\/li>\n<\/ul>\n<\/li>\n
- GSL.util: Utilities<\/a>\n
- \n
- narrow<\/span><\/li>\n
- narrow_cast()<\/span><\/li>\n
- not_null<T><\/span><\/li>\n
- finally<\/span><\/li>\n<\/ul>\n<\/li>\n
- GSL.concept: Concepts<\/a>\n
- \n
Range<\/code><\/li>\nString<\/code><\/li>\nNumber<\/code><\/li>\nSortable<\/code><\/li>\nPointer<\/code><\/li>\n- …<\/li>\n<\/ul>\n
<\/p>\n<\/li>\n<\/ul>\n
You may wonder why the GSL has its own smart pointer gsl::unique_ptr<\/span> and gsl::shared_ptr<\/span> because the C++11 standard has std::unique_ptr<\/span> and std::shared_ptr.<\/span> The idea is simple: you can use the GSL with a compiler that does not support C++11. Many functions and types the GSL support may become part of C++20. That holds, at least for the concepts and the assertions. It is also probable that the remaining parts will become part of upcoming C++ standards.<\/p>\n<\/p>\n
The components<\/h2>\n
Let’s have a look at the Views,<\/p>\n
GSL.view: Views<\/h3>\n
A view is never an owner. In the case of a gsl::span<T><\/span>, it represents a non-owning range of contiguous memory. This can be an array, a pointer with a size, or a std::vector<\/span>. The same holds for gsl::string_span<T><\/span> or a zero-terminated C strings: gsl::(cw)string.<\/span> The main reason for having a gsl::span<T><\/span> is that a plain array will be decayed to a pointer if passed to a function; therefore, the size is lost.<\/p>\n
gsl::span<T><\/span><\/strong> automatically deduces the size of the plain array or the std::vector.<\/span> If you use a pointer, you have to provide the size.<\/p>\n
\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> copy_n(const<\/span> T*<\/span> p, T*<\/span> q, int<\/span> n){}\r\n\r\ntemplate<\/span> <<\/span>typename<\/span> T><\/span>\r\nvoid<\/span> copy(gsl::<\/span>span<<\/span>const<\/span> T><\/span> src, gsl::<\/span>span<<\/span>T><\/span> des){}\r\n\r\nint<\/span> main(){\r\n \r\n int<\/span> arr1[] =<\/span> {1<\/span>, 2<\/span>, 3<\/span>};\r\n int<\/span> arr2[] =<\/span> {3<\/span>, 4<\/span>, 5<\/span>};\r\n \r\n copy_n(arr1, arr2, 3<\/span>); \/\/ (1)<\/span>\r\n copy(arr1, arr2); \/\/ (2)<\/span>\r\n \r\n}\r\n<\/pre>\n<\/div>\n<\/p>\n
In contrast to the function copy_n<\/span> (1), you have not provided the number of elements for the function copy<\/span> (2). Hence, a common cause of errors is gone with gsl::span<T><\/span>.<\/p>\n
There are various kinds of owners in the GSL.<\/p>\n
GSL.owner: Ownership pointers<\/h3>\n
I assume you know std::unique_ptr<\/span> and std::shared_ptr<\/span>; therefore, you know gsl::unique_ptr<\/span> and gsl::shared_ptr<\/span>. If not, here are my posts about smart pointers<\/a>.<\/p>\n
gsl::owner<T*><\/span><\/strong> marks a pointer that owns the referenced object. You should use gsl::owner<T><\/span> if you can not use resource handles such as smart pointers or containers. The critical point about the owner is that you must explicitly free the resource. Raw pointers not marked as gsl::owner<T*> are considered non-owning in the C++ core guidelines. Therefore, you do not have to free the resource.<\/p>\n
gsl::dyn_array<T<\/span>> and gsl::stack_array<T><\/span> are two new array types.<\/p>\n
- \n
- gsl::dyn_array<T><\/span><\/strong> is a heap-allocated array with a fixed size of elements specified at run-time.<\/li>\n
- gsl::stack_array<T> <\/span><\/strong>is a <\/span>stack-allocated array with a fixed size of elements specified at run-time.<\/li>\n<\/ul>\n
GSL.assert: Assertions<\/h3>\n
Thanks to Expects()<\/span><\/strong> and Ensures()<\/strong>,<\/span> you can state preconditions and postconditions for your functions. You have to place them in the function body, but this will later be moved to the function declaration. Both functions are part of the contract proposal<\/a>.<\/p>\n
Here is a simple example using Expects()<\/span> and Ensures().<\/span><\/p>\n
\nint<\/span> area<\/span>(int<\/span> height, int<\/span> width)\r\n{\r\n Expects(height ><\/span> 0<\/span>); \r\n auto<\/span> res =<\/span> height *<\/span> width;\r\n Ensures(res ><\/span> 0<\/span>);\r\n return<\/span> res;\r\n}\r\n<\/pre>\n<\/div>\n<\/p>\n
GSL.util: Utilities<\/h3>\n
gsl::narrow_cast<T><\/span> and gsl::narrow<\/span> are two new casts.<\/p>\n
- \n
- gsl::narrow_cast<T><\/span><\/strong> is a static_cast<T><\/span> that only expresses its intent. A narrowing conversion may happen.<\/li>\n
- gsl::narrow<\/span><\/strong> is a static_cast<T><\/span> that throws a narrowing_error<\/span> exception if
static_cast<T>(x) != x<\/code>. <\/code><\/code><\/li>\n<\/ul>\ngsl::not_null<T*><\/span><\/strong> models a pointer that never should be a nullptr.<\/span> You will get a compiler error if you set a gsl::not_null<T*><\/span> pointer to a nullptr. You can even put a smart pointer such as std::unique_ptr<\/span> or std::shared_ptr<\/span> into a gsl::not_null<T*>. <\/span>Typically, you use gsl::not_null<T*><\/span> for function parameters and their return type. Therefore, you can not forget to check if a pointer holds a value.<\/p>\n
\nint<\/span> getLength<\/span>(gsl::<\/span>not_null<<\/span>const<\/span> char<\/span>*><\/span> p); \/\/ p cannot be a nullptr<\/span>\r\n\r\nint<\/span> getLength<\/span>(const<\/span> char<\/span>*<\/span> p); \/\/ p can be a nullptr<\/span>\r\n<\/pre>\n<\/div>\n<\/p>\n
Both functions state their intent explicitly. The second one can accept a nullptr.<\/span><\/p>\n
finally<\/span><\/strong> allows you to register a callable that will run at the end of the scope.<\/p>\n
\nvoid<\/span> f<\/span>(int<\/span> n)\r\n{\r\n void<\/span>*<\/span> p =<\/span> malloc(1<\/span>, n);\r\n auto<\/span> _ =<\/span> finally([p] { free(p); });\r\n ...\r\n}\r\n \r\n<\/pre>\n<\/div>\n<\/p>\n
At the end of the function f,<\/span> the lambda function [p] { free(p); }<\/span> will be invoked automatically.<\/p>\n
According to the C++ core guidelines, you should consider finally<\/span> as a last resort if you can not use proper resource management such as smart pointers or STL containers.
<\/code><\/p>\nGSL.concept: Concepts<\/h3>\n
I make it short because most concepts are defined in the Ranges TS<\/a>. Here are my posts on concepts<\/a>.<\/p>\n
My last words<\/h2>\n
I’m impressed by the guideline support library. What I like, in particular, is that it requires no C++11 conformant compiler. You can even use it in legacy code, making it a lot more memory- and type-safe. I forgot that the GSL “aim for zero-overhead when compared to equivalent hand-written checks.”. <\/strong>That’s a promise.
<\/strong><\/p>\nWhat’s next?<\/h2>\n
- gsl::narrow<\/span><\/strong> is a static_cast<T><\/span> that throws a narrowing_error<\/span> exception if
- gsl::stack_array<T> <\/span><\/strong>is a <\/span>stack-allocated array with a fixed size of elements specified at run-time.<\/li>\n<\/ul>\n
- narrow_cast()<\/span><\/li>\n
- Ensures()<\/span><\/li>\n<\/ul>\n<\/li>\n
- unique_ptr<T><\/span><\/li>\n
- string_span<T><\/span><\/li>\n
- span<T><\/span><\/li>\n
- GSL.view: Views<\/a>\n