Programming in C: Few Tidbits #7

  1    _Alignof operator

_Alignof operator [that was introduced in C Standard Revision, C11] returns the alignment in bytes for the specified type. An alignment is an integer value representing the number of bytes between successive addresses in memory at which a given object can be allocated.

Some processors (such as SPARC family) require the data to be aligned on their natural boundaries. Aligned data allows the processor to fetch data from the memory in an efficient manner. Likewise misaligned data may cause additional memory accesses or a hardware fault in some cases.

Each of the primitive C data types have an alignment associated with them. The alignment requirement for each of the types can be queried using the _Alignof operator as shown below. For instance, an int data type is required to be aligned on 32-bit (4 byte) boundaries. That is, the memory address for the int data must be divisible by 4.

eg.,

% cat align.c

#include <stdio.h>
#include <stdarg.h>
..
printf("sizeof char        = %2d _Alignof char        = %2d\n", sizeof(char), _Alignof(char));
printf("sizeof short       = %2d _Alignof short       = %2d\n", sizeof(short), _Alignof(short));
printf("sizeof int         = %2d _Alignof int         = %2d\n", sizeof(int), _Alignof(int));
printf("sizeof long        = %2d _Alignof long        = %2d\n", sizeof(long), _Alignof(long));
printf("sizeof float       = %2d _Alignof float       = %2d\n", sizeof(float), _Alignof(float));
printf("sizeof double      = %2d _Alignof double      = %2d\n", sizeof(double), _Alignof(double));
printf("sizeof long long   = %2d _Alignof long long   = %2d\n", sizeof(long long), _Alignof(long long));
printf("sizeof long double = %2d _Alignof long double = %2d\n", sizeof(long double), _Alignof(long double));
printf("sizeof pointer     = %2d _Alignof pointer     = %2d\n", sizeof(void *), _Alignof(void *));
..

% cc -xlang=c11 -o align  align.c <-- latest Sun Studio 12.x C compiler

% ./align     <-- 32-bit executable

 sizeof char        =  1 _Alignof char        =  1
 sizeof short       =  2 _Alignof short       =  2
 sizeof int         =  4 _Alignof int         =  4
 sizeof long        =  4 _Alignof long        =  4
 sizeof float       =  4 _Alignof float       =  4
 sizeof double      =  8 _Alignof double      =  8
 sizeof long long   =  8 _Alignof long long   =  8
 sizeof long double = 16 _Alignof long double =  8
 sizeof pointer     =  4 _Alignof pointer     =  4

In general, the _Alignof value is the same as the value for sizeof for primitive data types. However structures are aligned to the alignment requirements of the widest type (largest element). In both cases, usually the compiler handles the alignment requirement for developers by padding where needed. In the following example, the compiler may try to construct the mix structure in such a way that member l (a long) falls on a 32-bit boundary.

eg.,

..
typedef struct { char c; short s; long l; } mix;
printf("\n sizeof struct mix = %2d _Alignof struct mix = %2d", sizeof(mix), _Alignof(mix));
..

Output:
 sizeof struct mix =  8 _Alignof struct mix =  4

  2    Alternative to curly braces - { }

If you prefer to use some other symbol in place of open and close braces { } (known as punctuators)), try <% %>. These symbols/punctuators must appear in pairs and cannot be mixed -- that is, either use { } or <% %> as separators but do not mix them up.

Other possible alternatives:
<: :> in place of [ ], %: in place of # and %:%: in place of ##.

eg.,

% cat -n punct.c
     1  %:include <stdio.h>
     2
     3  %:define SOMESTR "some random string"
     4
     5  void main()
     6  <%
     7          char somestr<::> = SOMESTR;
     8          puts(somestr);
     9  %>

% cc -o punct punct.c
% ./punct
some random string

  3    Compound Literals

Literals represent fixed values in source code. For instance, "chip" is a string literal, 2 is an integer literal of type int, 3.14 is a floating point literal of type float and so on. Similarly compound literals represent the contents for slightly complex objects/aggregate types such as arrays or structures (and unions too though union is not classified as an aggregate type given that an object with union type can only contain one member at a time). The compound literal provides an unnamed object of the specified type whose value is specified by the initializer list.

eg.,

(int []){ 10, 20, 30, 40 };

is a compound literal which is identical to an array initialization such as the following with the exception that it has no name.

int tens[] = { 10, 20, 30, 40 };

Compound literals are useful when an instance of aggregate or union type are used only once. For instance, compound literals as function arguments eliminate the need for temporary variables. The following example illustrates the syntax and usage of compound literals with the help of an aggregate type, struct.

eg.,

% cat -n compound.c

     1  #include <stdio.h>
     2
     3  typedef struct woo { int x; float y; char z; } foo;
     4
     5  void print( foo f ) {
     6          printf("x = %d y = %0.2f z = %c\n",
     7                  f.x, f.y, f.z);
     8  }
     9
    10  void main() {
    11          foo s = { 75, 32.32, 'Z' };  /* initialization using a temp variable */
    12          print( s );
    13          print( (foo) { 123, 55.01, 'K' } ); /* compound literal; no temp variable */
    14  }

% cc -o compound compound.c
% ./compound
x = 75 y = 32.32 z = Z
x = 123 y = 55.01 z = K

Scope

Unnamed objects (compound literals) have automatic storage duration associated with the block in which it was created -- that is, the memory buffer will be deallocated automatically upon block exit. If the compound literal occurs outside the body of a function, the object has static storage duration -- that is, its lifetime is the entire execution of the program. The expressions in the global/file scope compound literal are required to be constant.