C

C/C++: Change position of bytes 1 and 2 with bytes 3 and 4 in a 32bit unsigned integer

 in C / C++  tagged byte mask / byte operations / byte shift / C++ by

The following function will produce a new 32bit value where bytes 1 and 2 were moved in place of bytes 3 and 4 and vice versa.

[download id=”3642″]

#include <stdio.h>
#include <stdlib.h>

const unsigned int move_bytes_1_2_after_4 (const unsigned int input) {
  //We get the two leftmost bytes and move them to the positions of the two rightmost bytes.
  const unsigned int first_two_bytes = (input >> 16) & 0x0000FFFF;
  //We get the two rightmost bytes and move them to the positions of the two leftmost bytes.
  const unsigned int last_two_bytes = (input << 16) & 0xFFFF0000;
  //We combine the two temporary values together to produce the new 32bit value where bytes 1 and 2 were moved in place of bytes 3 and 4 and vice versa.
  return (first_two_bytes | last_two_bytes);
}

int main(void) {
  const unsigned int value = 0xABCD0123;
  printf ("Original: 0x%08x\n", value);
  const unsigned int modified = move_bytes_1_2_after_4(value);
  printf ("Modified: 0x%08x\n", modified);
  return EXIT_SUCCESS;
}

Executing the above code will produce the following output:

Original: 0xabcd0123
Modified: 0x0123abcd

[download id=”3642″]

C: Implicit declaration of function ‘read’ and ‘write’ 6

 in C  tagged implicit declaration / read / unistd.h / write by

While working on an socket-based application, we received the following warnings from the compiler:

implicit declaration of function 'read'
implicit declaration of function 'write'

read and write functions are declared in unistd.h which we forgot to include in our code.

Adding the directive


#include <unistd.h>

to the source file that used read and/or write removed the warnings.

C/C++: How do you set GDB debug flag (-g) with cmake? 1

 in C / C++ / Programming  tagged cmake / debug / debug metadata / gdb / RelwithDebInfo / symbol table by

Solution 1: Modify the CMakeLists.txt file

Add the following line to your CMakeLists.txt file to set the compilation mode to Debug (non-optimized code with debug symbols):

set(CMAKE_BUILD_TYPE Debug)

Add the following line to your CMakeLists.txt file to set the compilation mode to RelWithDebInfo (optimized code with debug symbols):

set(CMAKE_BUILD_TYPE RelWithDebInfo)

Solution 2: Add a command line argument to your cmake command:

Modify as follows your cmake command to set the compilation mode to Debug (non-optimized code with debug symbols):

cmake -DCMAKE_BUILD_TYPE=Debug <path and other arguments>

Modify as follows your cmake command to set the compilation mode to RelWithDebInfo (optimized code with debug symbols):

cmake -DCMAKE_BUILD_TYPE=RelWithDebInfo <path and other arguments>

Bonus material:

The difference between Debug and RelwithDebInfo modes is that RelwithDebInfo optimizes the code similarly to the behavior of Release mode. It produces fully optimized code, but also creates the symbol table and the debug metadata to give the debugger as much input as it is possible to map the execution back to the original code at any time.

Code build with RelwithDebInfo mode should not have it’s performance degraded in comparison to Release mode, as the symbol table and debug metadata that are generated do not live in the executable code section, so they should not affect the performance when the code is run without a debugger attached.

How does the expression, “*pointer++” evaluate?

 in C / C++  tagged C/C++ / increment / pointer / pointers by

*pointer++ will increment the position of the pointer first but it will return the value that was pointed before the position of the pointer changed.

*pointer++ is equivalent to *(pointer++). This happens because the postfix ++ and -- operators have higher precedence than the indirection (dereference).
You can read more about the precedence order at this very helpful article at Wikipedia: https://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence

To increment the value pointed to by pointer, use (*pointer)++.

To increment the position of the pointer and return the value that is pointed after the position of the pointer changed use *++pointer.

Examples

The following example will increment the position of the pointer but return the value that was originally pointed.
By the end of the following block, pointer will point to position 1 and the value variable will have the value 11.


const unsigned int values[] = {11, 12, 14, 18};
const unsigned int *pointer = values;
const unsigned int value = *pointer++;

The following example will increment the position of the pointer and return the value that the new position is pointing to.
By the end of the following block, pointer will point to position 1 and the value variable will have the value 12.


const unsigned int values[] = {11, 12, 14, 18};
const unsigned int *pointer = values;
const unsigned int value = *++pointer;