Dimensional Data

Impact-Site-Verification: 9054929b-bb39-4974-9313-38176602ccee The Lambda Expression construct is introduced in C++ 11 and further developed in the C++14, C++17, and C++20 standards. C++14 standard introduced the generalized lambda capture (init capture) that allows you to specify generalized captures, it allows to use move capture in lambdas. In C++14, lambda expressions are improved by the generalized lambda (generic lambda) and by this generalized lambda captures. In this post, we explain how to use generalized lambda captures in modern C++ What is a lambda in 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 them, please check these two posts that we released before. How to use a generalized lambda function in 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. The basic syntax of a Lambda Expression in C++ is; Datatype Lambda Expression = [Capture Clause] (Parameter List) -> Return Type { Body } Generalized lambdas can be defined with the auto keyword that comes with C++11. We can define a generic lambda with the auto keyword as below. auto add_things = []( auto a, auto b ) {    return a + b; }; We can use this lambda with an int type, int x = add_things( 10, 20 ); or we can use it with a float type, float f = 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. What are generalized lambda captures in C++? The Lambda Expression construct is introduced in C++ 11 and further developed in the C++14, C++17, and C++20 standards. C++14 standard introduced the generalized lambda capture (also known as init capture) that allows you to specify generalized captures. In C++14, lambda expressions are improved by the generalized lambda (generic lambda) and by this generalized lambda captures, it allows to use move capture in lambdas. A generalized capture is a new and more general capture mechanism, it allows us to specify the name of a data member in the closure class generated from the lambda, and an expression initializing that data member. Lambdas can capture expressions, rather than just variables as in functions, and this feature allows lambdas to store move-only types. How to use generalized lambda captures in C++ Let’s see how we can use generalized lambda captures in modern C++, std::move can be used to move objects in lambda captures as below, struct […]

C++11 allowed lambda functions to deduce the return type based on the type of the expression given to the return statement. The C++14 standard provides return type deduction in all functions, templates, and lambdas. C++14 allows return type deduction for functions that are not of the form return expressions. In this post, we explain the auto keyword, what is an auto type deduction, and how we can use it in functions, templates, and lambdas. Here are some very simple examples. What is the auto keyword in C++? The auto keyword arrives with the new features of the C++11 standard and above. It can be used as a placeholder type specifier (an auto-typed variable), or it can be used in a function declaration, or a structured binding declaration. The auto keyword can be used with other new CLANG standards like C++14, C++17, etc. Here is a simple example of how to use auto-typed variables in C++.   unsigned long int L;   auto a = L; // a is automatically unsigned long int   The auto keyword was being used as an automatic data specifier (storage class specifier) until C++11. This feature was removed by the C++11 standard. What is auto return type deduction in C++? In object oriented programming, type inference or deduction means the automatic detection of the data type of an expression and its conversion to a new type in a programming language and auto return type deduction may deduce return. type (i.e. float parameters to int return values). By the C++14 standard, we can use auto return type deduction in functions, templates, in lambdas. Now let’s see some simple examples that show how we can use them. If you want to use return type deduction in functions, templates, and lambdas, it must be declared with auto as the return type, but without the trailing return type specifier in C++11. The auto return type deduction feature can be used with parameter types in functions. Here is a simple example,   auto sq(int r)   // auto return type deduction in function { return r*r; }   The auto return type deduction feature can be used on modified parameters. Here is a simple example.   auto inc(int r)  // auto return type deduction in function { return ++r; }   The auto return type deduction feature can be used with references in functions.   auto& zero(int& r) // auto return type deduction in function { r = 0; return r; }   The auto return type deduction can be used with templates. Here is an example:   template auto template_sq(T t) // auto return type deduction in template { return (int)(t*t); // deduce to int }   The auto keyword is very useful in lambda declarations and it has an auto return type deduction feature too. See a simple lambda example below.   auto lambda_sq = [](int r)  // auto return type deduction in lambda { return r*r; };   Note that one of the important differences between lambdas and normal functions is that normal functions can refer to themselves by name but lambdas cannot. Is there a full example of auto return type deduction in C++? Here is a full example about auto return type deduction in functions, a template and a lambda. 1 2 3 4 5 6 7 8 9 10 11 […]

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 […]

C++11 allows the use of atomics in signal handlers, and with the advent of C++ 17 the signal handler feature was again improved. The std::atomic_flag is an atomic boolean type that is guaranteed to be lock-free and can be used in signal handlers. Moreover, the  header in C++ has an integer type std::sig_atomic_t that can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals. In this post, we explain how to use atomic_flag in C++. How to allow atomics use in C++ signal handlers? The header in C++ (or signal.h in C) has an an integer type std::sig_atomic_t that can be accessed as an atomic entity even in the presence of asynchronous interrupts made by signals. In this post, we explain how to allow atomics use in C++ signal handlers. Here is how we can use it:   #include   volatile sig_atomic_t flag = 0;   Is there a full example of how to use atomics in C++ signal handlers? Here is an example that has a signal handler and uses sig_atomic_t flag from 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39   #include #include   volatile sig_atomic_t flag = 0;   void handler(int signum) {    flag = 1 ; }   bool signal_check() {   if ( signal( SIGINT, handler) == SIG_ERR )   { return false;   }     if (flag) std::cout

C++ is very strong in every aspect of modern programming. Volatile types are used with the volatile keyword. It is a lesser known type qualifier that is important to read types or objects whose value can be modified at any time. The volatile keyword is useful in memory-mapped applications, generally these are from a hardware device, from a sensor, from an input device, or data from on an IoT. For example, an application reading dynamic data from the registers of a medical robot and decides what to do with that robot arm. In this post we will explain the volatile keyword in C++ and how can we use volatile type specifier. What is volatile keyword in C++? Volatile types are declared with the volatile keyword with a type declaration. Here’s how it is used.   volatile ;   We can use volatile on standard types, structs, unions. We can use them with pointers too. Here are some examples of how to use the volatile keyword in C++.   volatile int x;   volatile unsigned long int *p;   The volatile type specifier is used to change the variable whose values can be changed at any time and don’t have any constant value. The volatile qualifier is important to prevent the compiler from applying any optimizations on objects that can change in ways that cannot be determined by the compiler. Generally used in loops to read data, if you read those kinds of data without volatile types, the compiler and its optimizer can see the loop as useless. Your loop will never read the exact data in that time. For example, in this example:   unsigned int x = 255;   do {    // … }while( x == 255 );   compiler optimization covert this as below:   unsigned int x = 255;   do {   // … }while( true );   In other words, our loop becomes infinite by being true always even if the value of x is changed in some steps inside. To solve this, we can use volatile, thus we will keep reading data from x in do-while loop. Here is the example,   volatile unsigned int x = 255;   do {     // … }while( x == 255 );   If you want to keep reading x data from that address, you must use volatile specifier for the x type. This is why the volatile specifier is needed when developing embedded systems or device drivers. If we need to read or write a memory-mapped hardware device, we can use volatile type specifier on these kinds of data. Because data on that device register could change at any time, so we need to use volatile keyword to ensure that we read data on that time and such accesses aren’t optimized away by the compiler. Another need is some processors have floating point registers that have more than 64 bits of precision and if you need consistency then you can force each operation to go back to memory by using the volatile keyword.   Volatile specifier is also useful for some algorithms, such as Kahan summations, etc. Is there an example to use volatile keyword in C++? Assume that we have an address in our device or in a library of a driver, let’s set this address to a volatile […]