C/Visual C - Acotar el tamaño de argumentos variables.

 
Vista:

Acotar el tamaño de argumentos variables.

Publicado por Jose (3 intervenciones) el 15/11/2002 14:24:41
Hola

necesito alguna forma para poder acotar los argumentos variables a 512 posiciones,

Estoy utilizando va_start, vsprintf(), va_end. pero si supera el tamaño de 512 (No puedo aumentar este tamaño) me devuelve -1.

gracias
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Acotación de argumentos variables a 512 posiciones en C

Publicado por Alejandro (913 intervenciones) el 02/04/2025 21:42:16
José, para acotar los argumentos variables a un tamaño máximo de 512 caracteres al utilizar `va_start`, `vsprintf()`, y `va_end`, puedes implementar una función que verifique el tamaño del buffer antes de realizar la operación de formato. Aquí tienes un ejemplo de cómo hacerlo:

Ejemplo de código



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
40
41
42
43
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
 
#define MAX_SIZE 512
 
int safe_vsnprintf(char *buffer, size_t size, const char *format, va_list args) {
    // Usamos vsnprintf para evitar desbordamientos de buffer
    int n = vsnprintf(buffer, size, format, args);
 
    // Verificamos si el tamaño excede el límite
    if (n < 0 || n >= size) {
        // Si hay un error o el tamaño excede, retornamos -1
        return -1;
    }
    return n; // Retornamos el número de caracteres escritos
}
 
int my_printf(const char *format, ...) {
    char buffer[MAX_SIZE];
    va_list args;
 
    va_start(args, format);
    int result = safe_vsnprintf(buffer, sizeof(buffer), format, args);
    va_end(args);
 
    if (result < 0) {
        fprintf(stderr, "Error: el tamaño del mensaje excede 512 caracteres.\n");
        return -1; // Manejo de error
    }
 
    // Imprimir el resultado
    printf("%s", buffer);
    return result; // Retornamos el número de caracteres escritos
}
 
int main() {
    // Ejemplo de uso
    my_printf("Este es un mensaje de prueba con un número: %d\n", 42);
    my_printf("Este es un mensaje que excede el tamaño permitido: %s\n", "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.");
 
    return 0;
}

Explicación del código:


1. Función `safe_vsnprintf`: Esta función utiliza `vsnprintf` para formatear la cadena. `vsnprintf` es preferible a `vsprintf` porque limita el número de caracteres escritos, evitando desbordamientos de buffer. Si el tamaño excede 512 caracteres, se devuelve -1.

2. Función `my_printf`: Esta función es un envoltorio alrededor de `safe_vsnprintf`. Se encarga de manejar los argumentos variables y verificar si el resultado es válido. Si el tamaño excede el límite, se imprime un mensaje de error.

3. Uso en `main`: Se muestran ejemplos de cómo llamar a `my_printf`. El segundo ejemplo está diseñado para exceder el límite de 512 caracteres, lo que desencadenará el manejo de errores.

Consideraciones:


- Asegúrate de que el formato de la cadena y los argumentos sean correctos para evitar errores de formato.
- Este enfoque te permite manejar de manera segura los argumentos variables y acotar el tamaño de la salida a 512 caracteres.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar