XQA
Back to C Programming
2026-04-127 min read

Generic selection

Learn Generic selection step by step with clear examples and exercises.

Title: Mastering Generic Selection in C Programming - A full guide

Why This Matters

In the realm of C programming, generic selection is a powerful tool that allows you to write flexible and adaptable code. It's essential for creating reusable functions, handling different data types efficiently, and avoiding unnecessary typecasting. Understanding generic selection can help you tackle real-world coding challenges, ace programming interviews, and debug complex issues in your projects.

By mastering generic selection, you will be able to write cleaner, more efficient code that is easier to maintain and extend over time. This guide will provide a comprehensive overview of the concept, including its syntax, usage, and common pitfalls.

Prerequisites

Before diving into generic selection, ensure you have a solid grasp of the following concepts:

  1. Basic C syntax and data types (int, char, float, etc.)
  2. Functions and function prototypes
  3. Preprocessor directives (#include, #define)
  4. Pointers and arrays
  5. Conditional statements (if, else)
  6. Loops (for, while, do-while)
  7. Basic input/output functions (printf, scanf)
  8. Structures and unions
  9. Function pointers
  10. Variable-length arrays (VLAs)
  11. Understanding the difference between lvalues and rvalues - This is crucial for understanding _Generic's behavior with expressions involving side-effects or value calculations.
  12. Familiarity with C99 and C11 features - To use _Generic, ensure you understand the new features introduced in C99 and C11, such as _Bool, compound literals, and variable-length arrays (VLAs).

Core Concept

Generic selection, introduced in C11, provides a way to choose one of several expressions at compile time based on the type of a controlling expression. This feature is particularly useful when writing generic functions that can handle multiple data types without explicit typecasting.

The syntax for using _Generic is as follows:

_Generic(controlling-expression, association-list)

Here's a breakdown of the components:

  1. controlling-expression - Any expression (except for the comma operator) whose type must be compatible with one of the type-names if the default association is not used.
  2. association-list - A comma-separated list of associations, each of which has the syntax type-name : expression. There may only be one association that uses the keyword default. If no type matches the controlling expression or the default association is not used, the program will not compile.

Example:

#include <stdio.h>

void print_type(int x) { printf("The type is integer.\n"); }
void print_type(float x) { printf("The type is float.\n"); }
void print_type(char x) { printf("The type is character.\n"); }

_Generic(10,
int: print_type(int),
default: print_type(char)
);

In this example, the controlling expression 10 is of type int, so the function print_type(int) will be called. If the controlling expression had been a character or float, the corresponding function would have been called instead.

Worked Example

Let's create a generic function that can calculate the area of various shapes based on their type:

#include <stdio.h>
#include <math.h>

enum shape_type { CIRCLE, SQUARE, RECTANGLE };

typedef struct { double radius; } circle_t;
typedef struct { double side; } square_t;
typedef struct { double length, width; } rectangle_t;

double area(enum shape_type shape, void* data) {
_Generic(*data)(double d) {
case radius: return M_PI * d * d;
case side: return d * d;
case length: return d;
case width: return d;
default: return 0;
}

if (shape == CIRCLE)
return _Generic(*data)(radius);
else if (shape == SQUARE || shape == RECTANGLE)
return _Generic(*data)(length, width);
else
printf("Unsupported shape type.\n");
return 0;
}

int main() {
circle_t circle = {.radius = 5};
square_t square = {.side = 4};
rectangle_t rectangle = {.length = 3, .width = 2};

printf("Area of circle: %.2f\n", area(CIRCLE, &circle));
printf("Area of square: %.2f\n", area(SQUARE, &square));
printf("Area of rectangle: %.2f\n", area(RECTANGLE, &rectangle));

return 0;
}

In this example, we define three different types (circle_t, square_t, and rectangle_t) that hold the necessary data for each shape. The area() function uses generic selection to determine the appropriate calculation based on the passed shape type and data pointer. If an unsupported type is encountered, a message is printed instead.

Common Mistakes

  1. Forgetting to define the default association - If no associations match the controlling expression and there's no default association, the program will not compile.
  2. Using incompatible types within a single association - This occurs when you try to use both type-name and an expression that evaluates to a compatible type within the same association.
  3. Misunderstanding lvalue conversions - It's essential to understand that only type conversions occur during lvalue conversions; no side-effects or value calculations take place.
  4. Ignoring the absence of the comma operator in the controlling expression and associations - The controlling expression and each association must not contain a comma operator.
  5. Not handling NULL correctly - In generic functions, it's crucial to check for NULL before performing any operations on the passed pointer.
  6. ### Subheadings under Common Mistakes:
  • Using incompatible types within a single association - This occurs when you try to use both type-name and an expression that evaluates to a compatible type within the same association.
  • Forgetting to include C11 header files - To use _Generic, ensure you include the appropriate C11 headers (`, , or `) in your code.
  1. Not handling NULL gracefully - In generic functions that accept pointers, it's essential to check for NULL before performing any operations on the passed pointer to avoid undefined behavior.
  2. ### Subheadings under Common Mistakes:
  • Handling NULL gracefully - Implementing a null check at the beginning of your generic function ensures that your code doesn't crash when dealing with NULL pointers.
  1. Not considering side-effects in lvalues - When using _Generic, be aware that only type conversions occur during lvalue conversions; no side-effects or value calculations take place.
  2. ### Subheadings under Common Mistakes:
  • Understanding the implications of lvalue conversions - Recognize that lvalues must not contain side-effects or value calculations to work correctly with _Generic.

Practice Questions

  1. Write a generic function that can calculate the factorial of a number for integers and compute the gamma function (Euler's integral of the second kind) for floating-point numbers.
  2. Create a generic function that can find the maximum value between an integer, float, and character in a single function call.
  3. Implement a generic function that swaps two variables of any type without using temporary variables.
  4. ### Subheadings under Practice Questions:
  • Using _Generic to implement a custom comparison function - Write a generic comparison function that can compare integers, floats, characters, and strings based on their respective comparison operators (``, etc.)
  • Implementing a generic sorting algorithm - Create a generic quicksort or mergesort algorithm that can handle arrays of different data types.
  1. Write a generic function that calculates the Fibonacci sequence for integers and computes the exponential function for floating-point numbers.
  2. ### Subheadings under Practice Questions:
  • Using _Generic to implement a custom arithmetic function - Create a generic arithmetic function that can perform addition, subtraction, multiplication, and division on integers, floats, and characters.
  • Implementing a generic search algorithm - Write a generic binary search or linear search algorithm that can handle arrays of different data types.
  1. Implement a generic function that calculates the determinant of a matrix for integer matrices and computes the trace of a matrix for floating-point matrices.
  2. ### Subheadings under Practice Questions:
  • Using _Generic to implement a custom matrix operation - Create a generic function that can perform matrix multiplication, addition, subtraction, and transposition on matrices of different data types.
  • Implementing a generic polynomial evaluation algorithm - Write a generic function that can evaluate a polynomial (coefficients as an array) for integers and floating-point numbers.

FAQ

  1. Can I use _Generic with arrays or variable-length arrays (VLA)?
  • No, _Generic cannot be used with VLAs because they are variably-modified types. However, you can create a wrapper function to handle arrays of known sizes.
  1. Is it possible to use _Generic for operator overloading in C?
  • Unfortunately, C does not support operator overloading like C++. However, _Generic can be used to implement custom behavior for specific data types or operators within a limited scope.
  1. Are there any limitations on the expressions that can be used with _Generic associations?
  • Yes, expressions in _Generic associations cannot contain the comma operator and must not involve side-effects. Additionally, the expression associated with the default case should have the same return type as the other expressions.
  1. ### Subheadings under FAQ:
  • Can I use _Generic to implement a custom cast operator?
  • While C does not support operator overloading, you can create a generic function that performs a custom cast based on the data type of the controlling expression.
  • What happens if no associations match the controlling expression in _Generic?
  • If no associations match the controlling expression and there's no default association, the program will not compile. It is essential to include a default association or handle all possible types explicitly.