Dimensional Data

Lambda Expressions allow users to write an inline expression that can be used for short snippets of code in your C++ app which are not going to be reused and don’t require naming. The Lambda Expression construct is introduced in C++ 11 and further developed in the C++14, C++17, and C++20 standards. In C++14, lambda expressions are improved by the generalized lambda (generic lambda) or initialized lambda feature, and in this post, we remember what lambda is and explain what a generic lambda is, and how we can use it. What is a lambda expression in modern C++? A Lambda Expression defines an anonymous function or a closure at the point where it is used. You can think of a lambda expression as an unnamed function (that’s why it’s called “anonymous”). Lambda expressions help make code cleaner, and more concise and allow you to see behavior inline where it’s defined instead of referring to an external method, like a function. Lambda Expressions are an expression that returns a function object, and they are assignable to a variable whose data type is usually auto and defines a function object. The syntax for a lambda expression consists of specific punctuation with = [ ] ( ) { … } series.  If you are new to lambdas or want to know more about it, please check these two posts that we released before. How to use a lambda expression in modern C++ Simple Syntax of Lambda Expression is;   Datatype Lambda Expression = [Capture Clause] (Parameter List) -> Return Type { Body }   Now let’s see this syntax in an example. We will define a lambda expression to combine datatypes;   int add_integers = []( int a, int b ) {    return a + b; };   and we can use lambda as below,   int x = add_integers( 10, 20 );   What is the generic lambda expression in modern C++? Before C++14, lambda function parameters need to be declared with concrete types, as in the given example above. C++14 has a new generic lambda feature that allows lambda function parameters to be declared with the auto-type specifier. Generalized lambdas can be defined with the auto keyword that comes with C++11 before. Let’s take the same integer example above, we can define a generic lambda with the auto keyword as below,   auto add_things = []( auto a, auto b ) {    return a + b; };   Generic lambdas are essentially templated functor lambdas. In example, the code above is equivalent to this code,   struct {    template      auto operator()( T x, U y ) const { return x + y; } } add_things{};   How to use generic lambdas in modern C++ We can use this lambda with int type,   int x = add_things( 10, 20 );   or we can use with float type,   float x = add_things( 10.f, 20.f );   or we can use it with bool, char, double, long long double,…etc types. This is why it is called as ‘generalized‘, it is a general form that we can use with any types. Very useful and powerful. Note that, auto type deduction is added into C++14, and generic lambdas feature follow the rules of template argument deduction. Is there an example of how to use generic lambdas […]

C++14 brings us fewer but useful features to modern C++ than the standards preceding it. The creator of C++, Bjarne Stroustrup says that improvements in C++14 were deliberately lower in quantity compared to C++11. One of the small but useful features is the introduction of “Binary Literals”. C++14 comes with the Binary Literals feature, and in this post, we explain how we can use binary bits.  Learn how to use binary literals in modern C++ A binary literal is an integer literal that your binary number begins with 0b or 0B and consists of a sequence of binary digits (base two). It is defined in  and provides a convenient way to represent a binary base-2 number (1 and 0), useful for the developers in IDE, and useful to compilers that understand it is a binary value. Here is a simple example of how we can use it.   #include   int main(){ int b1 = 0b00111011; }   Is there a simple example about how to use binary literals in modern C++? We can use it with digital separators, which are another feature of C++. Here is an example, this time we used constants.   const int b8 = 0b1111‘0000; const int b16 = 0b1111′0000‘1111’0000; const int b32 = 0b1111‘0000’1111‘0000’1111‘0000’1111‘0000;   Note that, we can NOT use digital separator after the 0b literal as below.   const int b8 = 0b‘1111’0000;   Is there a full example about how to use binary literals in modern C++? Here is a full example about how to use binary literals in C++. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21   #include #include   int main() { int b = 0b00111011;   int b8 = 0b1111‘0000; int b16 = 0b1111′0000‘1111’0000; int b32 = 0b1111‘0000’1111‘0000’1111‘0000’1111‘0000;   std::cout

In the history of modern C++, the C++14 standard brings us some very useful features. C++14 comes with the digit seperators feature. In C++14 and above, we can use the digit separator  to separate integer numbers. In this post, we explain, how to use digit separators in examples, How can I use use digit separators in modern C++? In C++14, there is a new Digit Separators feature. The digit separator is a single-quote character ‘ that can be used within a numeric literal for aesthetic readability. When you use digit separators, it does not affect the numeric value, but it is very useful when you are using bigger or longer digital numbers. It can be used with int, long int, long long int, float, double, auto, etc.  Here is a simple example to digit separators.   long long int LL = 123‘456’789;   Is there a full example about to use digit separators in modern C++ Here is a full example about to use digit separators in modern C++. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23   #include #include   int main() { int x = 1‘024;   unsigned int m = 128′000‘000;   long double pi = 3.141′592‘653’589;   long long int LL = 123‘456’789;   std::cout

A programming language consists of a lot of expressions in our source code. One of elements of expressions in C++ are literals. A more specific type of literal is Integer Literals. Integer literals are primary expressions that allow values of integer types (i.e., decimal, octal, hexadecimal) to be used in expressions directly. They are further improved by the boolean literals (binary digits) in C++14. In this post, we will explain and list the types of integer literals available to us in modern C++. What is integer literal in modern C++? Integer Literals in C++ are primary expressions that are used to indicate the base or the type of an integer value. They allow values of integer types to be used in expressions directly. They are further improved by the addition of boolean literals in C++ 14. We can categorize integer literals into two groups: Prefixes and Suffixes. What is the prefix integer literal in modern C++? Prefix Integer Literals are used to indicate the numeric base of the literal. For example, the prefix 0x indicates a hexadecimal base (i.e. value 0x10 indicates the value of 16). Here are the prefixes for integer literals (integer-prefix). Prefix Literal Base Example -no prefix- Decimal Literals Base 10 1024 0 (zero) Octa Literals Base 8 048 0x or 0X Hex Literals Base 16 0xFF 0b or 0B Binary Literals Base 2 0b01010111 Here are simple examples to prefix integer literals:   int d = 1024; // decimal int o = 076; // octal int x = 0xFF22CC; // hexadecimal int b = 0b10101111; // binary (C++14)   What is the suffix integer literal in modern C++? Suffix Integer Literals are used to indicate the type. For example, the suffix LL indicates the value is for the long long integer (i.e. value 98765432109876LL indicates it is a long long integer). When we use suffix, that means this type of the integer literal is the first type in which the value can fit, and there are other decimal types from the list of types that depends on which numeric base and suffix. Here are the suffixes for integer literals (integer-suffix), Suffix Decimal Type Other Decimal Types -no suffix- intlong intlong long int intunsigned intlong intunsigned long intlong long intunsigned long long int l or L long intunsigned long intlong long int long intunsigned long intlong long intunsigned long long int ll or LL long long int long long intunsigned long long int z or Z (C++23) the signed version of std::size_t the signed version of std::size_t std::size_t u or U unsigned intunsigned long intunsigned long long int unsigned intunsigned long intunsigned long long int ul or UL unsigned long intunsigned long long int unsigned long intunsigned long long int ull or ULL unsigned long long int unsigned long long int uz or UZ (C++23) std::size_t  std::size_t  Here are simple examples of how to suffix integer literals in C++.   int i1 = 2048; long i2 = 2048L; // or l long long i3 = 2048LL;  // or ll   unsigned int u1 = 2048u; // or U unsigned long int u2 = 2048ul; // or UL unsigned long long int u3 = 2048ull; // or ULL   The C++23 feature can be tested with this __cpp_size_t_suffix if definition as we show below.   #if __cpp_size_t_suffix >= 202011L // (C++23 feature) auto size1 = 0z; // or Z auto size2 = 40uz; // or UZ static_assert( std::is_same_v ); static_assert( std::is_same_v ); #endif   Is there a full example about integer literals in modern C++? Here is a full example of how to use integer literals that uses prefixes and suffixes in modern C++. 1 2 3 4 5 6 7 8 9 10 11 […]

Modern C++ has a lot of useful functions coming from C. One of them was the gets() function that we use to get string inputs and that we were able to use in C++11 or earlier. In C++14, the gets function was removed, while fgets or other input functions remain there. If you have older C++ code that uses the gets() functions your C++14 version compiler will not compile it. Why was the gets function removed? In this post, we explain what the gets function is, why the std::gets function was removed by the C++14 standards, and how can we use similar functions or alternatives to the gets() function. What was the gets() function considered dangerous in C++? In C++11 and before, we were able to gets function. The std::gets function was first defined in the C language and was available in C++11 and earlier. The gets function reads inputs into a given char string. When a char string has a newline character, it is considered the end of input, and an end-of-file condition occurs. The return value is captured on success, or a null pointer on failure. The syntax below is deprecated in C++11 and removed in C++14.   char* gets( char* str );   Here is an example of a dangerous gets function,   #include #include   int main() {    char str[8];      gets(str);      printf(str: %s“, str);      return 0; }   Why was the std::gets function removed In C++14? According to C++14 document N4140 (Page 1237), the “use of gets is considered dangerous“, because the std::gets function does not check the bounds of a char array. This makes gets extremely vulnerable to buffer-overflow attacks. In other words, the std::gets function cannot be used safely. The std::gets() function was deprecated in C++11 and removed completely in C++14. If you REALLY need to use it in your apps, then there are some alternatives – for example you can use std::fgets(). If we use gets(), it is impossible to tell without knowing the data in advance how many characters will be read, and because std:: gets() will continue to store characters past the end of the buffer, it is extremely ‘dangerous’ to use.  Here is the definition from C++14 (Document Number: N4140, Page 1237).   C.3.4 Clause 27: input/output library Change: gets is not defined. Rationale: Use of gets is considered dangerous. Effect on original feature: Valid C++ 2011 code that uses the gets function may fail to compile in this International Standard.   They added a note to [c.files] saying that the C function gets() is not part of C++ and they removed gets from tables 134 and 153. We should note that there are some compilers that still support the gets() function. The gets function may be only used if the program runs in an environment that restricts inputs from stdin. Are there any alternatives to the std::gets function in modern C++? First of all, never use std::gets() function, use std::fgets() instead or other input methods of modern C++. There is no way to check the size of input before we store data to that variable. If you have older C++ code that uses the gets function and you want to modernize it, you can use std::fgets() as shown below. 1 2 3 4 5 […]

C++ is very strong in every aspect of modern programming and evolves and refines itself even further with the release of each new C++ standard. While there are many new additions there are some features that are found not useful or dangerous in programming, thus the community offers its deprecation in the next standard and then it is generally removed in the following standard. C++14 came with a new deprecated attribute feature to allow marking an entity as deprecated – potentially obsolete and best avoided. In this post, we will explain what deprecated means and how can we use the [[deprecated]] and __declspec(deprecated) attributes in modern C++. What does deprecated mean in C++? Deprecation is the process of taking an older code part (a method, function, or property) and marking it as no longer being useful within the current version of the programming codebase (generally it is a standard, i.e. C++11, C++14) . It also flags that the deprecated feature will probably be removed in the next version of C++. Often this is because a feature or function has been found to be ‘dangerous’ or has been superseded or obsoleted by newer code. The deprecated attribute does not mean it is immediately removed from that C++ version (a standard or a library) because doing so may cause regression errors. Generally, a deprecated feature is going to be removed in the next version or standard. For example, the gets() function was found to have potentially dangerous (undesirable) behavior and it was deprecated in the C++11 standard and removed in the C++14 standard. Briefly, deprecated means, that part of code is considered outdated and not recommended to use, and that the keyword, feature, or function will probably be removed in a subsequent C++ standard. How can we use the deprecated attribute in C++? C++14, came with a new deprecated attribute feature to allow marking an entity deprecated, There are two options to declare something as deprecated. We can use [[deprecated]] and __declspec(deprecated) attributes. The deprecated attribute is very useful to mark your older functions that probably will be removed. When you are working on a code base which you share with other developers it is useful for them to know that a section of code they are viewing is potentially outdated or will be removed – and the deprecated attribute is the best way to do that. While this is necessary for compiler developers (i.e. C++ Builder, GCC, Visual C++), it is also very desirable for library developers. If you find any code that will be removed in the next version, first, you can release a version that has the affected code part marked as deprecated. Then in the next release, you can remove it from your library. This is the modern way of professional programming. The [[deprecated]] attribute allows marking the part of the code entity deprecated, which means it is still available to use but gives a warning from the compiler that the use of the code section is deprecated, it is discouraged and may allow ‘dangerous’ errors on runtime. Generally, a warning message is printed during compilation, and in the new modern IDEs there are warning icons displayed too as shown in the example below. Is there a simple example of how to use the deprecated attribute in C++? To deprecate a function, we can use […]