# cstdarg

***

**1. Variable Argument List in printf and scanf**

```cpp
#include <stdio.h>
#include <stdarg.h>

int main() {
    int a = 10;
    double b = 2.5;
    char c = 'a';
    printf("a = %d, b = %f, c = %c\n", a, b, c);
    return 0;
}
```

**2. Iterating over Variable Arguments**

```cpp
#include <stdio.h>
#include <stdarg.h>

int sum_args(int n, ...) {
    va_list args;
    va_start(args, n);
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += va_arg(args, int);
    }
    va_end(args);
    return sum;
}

int main() {
    int result = sum_args(3, 10, 20, 30);
    printf("Result: %d\n", result);
    return 0;
}
```

**3. Converting Variable Arguments to an Array**

```cpp
#include <stdio.h>
#include <stdarg.h>

int* args_to_array(int n, ...) {
    va_list args;
    va_start(args, n);
    int* arr = (int*)malloc(n * sizeof(int));
    for (int i = 0; i < n; i++) {
        arr[i] = va_arg(args, int);
    }
    va_end(args);
    return arr;
}

int main() {
    int* arr = args_to_array(3, 10, 20, 30);
    for (int i = 0; i < 3; i++) {
        printf("%d ", arr[i]);
    }
    free(arr);
    return 0;
}
```

**4. Passing Variable Arguments to a Function Pointer**

```cpp
#include <stdio.h>
#include <stdarg.h>

int sum_variadic(int n, ...) {
    va_list args;
    va_start(args, n);
    int sum = 0;
    for (int i = 0; i < n; i++) {
        sum += va_arg(args, int);
    }
    va_end(args);
    return sum;
}

int main() {
    int (*fptr)(int, ...) = &sum_variadic;
    int result = fptr(3, 10, 20, 30);
    printf("Result: %d\n", result);
    return 0;
}
```

**5. Using variadic macros**

```cpp
#include <stdio.h>
#include <stdarg.h>

#define PRINT_ARGS(...) do { va_list args; va_start(args, __VA_ARGS__); print_args(args); va_end(args); } while(0)

void print_args(va_list args) {
    while (1) {
        int arg = va_arg(args, int);
        if (arg == -1) break;
        printf("%d ", arg);
    }
    printf("\n");
}

int main() {
    PRINT_ARGS(1, 2, 3, 4, -1);
    return 0;
}
```

**6. Logging with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>

void log(const char* format, ...) {
    va_list args;
    va_start(args, format);
    vprintf(format, args);
    va_end(args);
}

int main() {
    log("Error: %d\n", 10);
    return 0;
}
```

**7. Generating Error Messages with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>

typedef struct Error {
    int code;
    char* message;
} Error;

Error create_error(int code, const char* format, ...) {
    Error error;
    error.code = code;

    va_list args;
    va_start(args, format);
    int len = vsnprintf(NULL, 0, format, args) + 1;
    error.message = (char*)malloc(len);
    va_end(args);

    va_start(args, format);
    vsnprintf(error.message, len, format, args);
    va_end(args);

    return error;
}

int main() {
    Error error = create_error(10, "Error: %d", 10);
    printf("%s\n", error.message);
    free(error.message);
    return 0;
}
```

**8. Parsing Command Line Arguments**

```cpp
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

int get_int_argument(int argc, char* argv[], const char* option) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], option) == 0) {
             if (i + 1 < argc) {
                 return atoi(argv[i + 1]);
             }
        }
    }
    return -1;
}

int main(int argc, char* argv[]) {
    int port = get_int_argument(argc, argv, "--port");
    if (port != -1) {
        printf("Port: %d\n", port);
    }
    return 0;
}
```

**9. Formatting a String with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>

char* format_string(const char* format, ...) {
    va_list args;
    va_start(args, format);
    int len = vsnprintf(NULL, 0, format, args) + 1;
    char* str = (char*)malloc(len);
    va_end(args);
    va_start(args, format);
    vsnprintf(str, len, format, args);
    va_end(args);
    return str;
}

int main() {
    char* str = format_string("Hello, %s!\n", "John");
    printf("%s", str);
    free(str);
    return 0;
}
```

**10. Creating a Custom Debug Function**

```cpp
#include <stdarg.h>
#include <stdio.h>

void debug(const char* format, ...) {
#ifdef DEBUG
    va_list args;
    va_start(args, format);
    vprintf(format, args);
    va_end(args);
#endif
}

int main() {
    debug("Error: %d\n", 10);
    return 0;
}
```

**11. Generating SQL Queries with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdlib.h>
#include <stdio.h>

char* build_sql_query(const char* format, ...) {
    va_list args;
    va_start(args, format);
    int len = vsnprintf(NULL, 0, format, args) + 1;
    char* query = (char*)malloc(len);
    va_end(args);
    va_start(args, format);
    vsnprintf(query, len, format, args);
    va_end(args);
    return query;
}

int main() {
    char* query = build_sql_query("SELECT * FROM users WHERE name = '%s'", "John");
    printf("%s\n", query);
    free(query);
    return 0;
}
```

**12. Combining Strings with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>

char* combine_strings(int n, ...) {
    va_list args;
    va_start(args, n);
    int total_len = 0;
    for (int i = 0; i < n; i++) {
        total_len += strlen(va_arg(args, char*)) + 1;
    }
    va_end(args);

    char* result = (char*)malloc(total_len);
    result[0] = '\0';
    va_start(args, n);
    for (int i = 0; i < n; i++) {
        strcat(result, va_arg(args, char*));
    }
    va_end(args);

    return result;
}

int main() {
    char* str = combine_strings(3, "Hello", " ", "World");
    printf("%s\n", str);
    free(str);
    return 0;
}
```

**13. Creating a CSV File with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>

void write_csv_row(FILE* file, int n, ...) {
    va_list args;
    va_start(args, n);
    for (int i = 0; i < n; i++) {
        fprintf(file, "%s", va_arg(args, char*));
        if (i < n - 1) {
            fprintf(file, ",");
        }
    }
    va_end(args);
    fprintf(file, "\n");
}

int main() {
    FILE* file = fopen("data.csv", "w");
    write_csv_row(file, 3, "John", "Doe", "100");
    fclose(file);
    return 0;
}
```

**14. Formatting a Table with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>

void print_table(int num_cols, ...) {
    va_list args;
    va_start(args, num_cols);
    for (int i = 0; i < num_cols; i++) {
        printf("%-20s", va_arg(args, char*));
    }
    va_end(args);
    printf("\n");
}

int main() {
    print_table(3, "Name", "Age", "Occupation");
    return 0;
}
```

**15. Creating a Custom Logger with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>
#include <time.h>

void log_message(const char* level, const char* format, ...) {
    time_t t = time(NULL);
    struct tm* tm = localtime(&t);
    char timestamp[20];
    strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S", tm);

    va_list args;
    va_start(args, format);
    fprintf(stdout, "[%s] [%s] ", timestamp, level);
    vfprintf(stdout, format, args);
    va_end(args);
    fprintf(stdout, "\n");
}

int main() {
    log_message("INFO", "Application started");
    return 0;
}
```

**16. Creating a Custom Assert Function with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>

void assert_condition(int condition, const char* format, ...) {
    if (!condition) {
        va_list args;
        va_start(args, format);
        vprintf(format, args);
        va_end(args);
        fprintf(stderr, "\n");
        exit(1);
    }
}

int main() {
    assert_condition(10 > 5, "10 is not greater than 5");
    return 0;
}
```

**17. Parsing a Command Line with Variable Arguments**

```cpp
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct CommandLineArgument {
    char* name;
    char* value;
} CommandLineArgument;

CommandLineArgument* get_command_line_argument(int argc, char* argv[], const char* name) {
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], name) == 0) {
            if (i + 1 < argc) {
                CommandLineArgument* arg = (CommandLineArgument*)malloc(sizeof(CommandLineArgument));
                arg->name = strdup(name);
                arg->value = strdup(argv[i + 1]);
                return arg;
            }
        }
    }
    return NULL;
}

int main(int argc, char* argv[]) {
    CommandLineArgument* arg = get_command_line_argument(argc, argv

```