Problemy z bezpieczeństwem typów
Ryzyko funkcji wariadycznych
Problemy z bezpieczeństwem typów to bezpłatna lekcja C Academy na CoddyKit. To lekcja 3 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej C Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs C Academy zawiera 4 lekcji w sumie.
Argumenty wariadyczne omijają kontrolę typów
Standardowe funkcje C sprawdzają zgodność argumentów z typami parametrów. Argumenty wariadyczne całkowicie pomijają tę kontrolę.
Kompilator nie może zweryfikować tego, co przekazujesz po ..., przez co łatwo o błędy i niebezpieczne sytuacje.
#include <stdio.h>
#include <stdarg.h>
int add(int n, ...) {
va_list a; va_start(a, n);
int s = 0;
for (int i = 0; i < n; i++) s += va_arg(a, int);
va_end(a);
return s;
}
int main(void) {
printf("%d\n", add(2, 3, 4));
return 0;
}Nieprawidłowy typ w va_arg
Jeśli argument zostanie odczytany jako niewłaściwy typ, wynikiem jest niezdefiniowane działanie.
Przekazanie wartości int, a odczytanie jej jako double powoduje ponowną interpretację niezwiązanych ze sobą bajtów i może dać losowy wynik albo doprowadzić do awarii.
#include <stdio.h>
#include <stdarg.h>
int read_int(int n, ...) {
va_list a; va_start(a, n);
int v = va_arg(a, int);
va_end(a);
return v;
}
int main(void) {
printf("%d\n", read_int(1, 100));
return 0;
}Niezgodność napisu formatującego
W funkcjach w stylu printf nieprawidłowy specyfikator jest klasycznym błędem. printf("%d", 3.14) odczytuje wartość typu double tak, jakby była typu int.
Współczesne kompilatory ostrzegają o niezgodnościach w literałach, ale nie potrafią wykrywać napisów formatujących tworzonych w czasie działania programu.
#include <stdio.h>
int main(void) {
double pi = 3.14;
printf("%f\n", pi);
return 0;
}Pułapki promocji liczb całkowitych
Małe typy są w części wariadycznej promowane do int. Dlatego nawet jeśli przekażesz wartość typu char, musisz odczytać ją z powrotem jako int.
Odczytanie jej jako char za pomocą va_arg(a, char) jest niezdefiniowane.
#include <stdio.h>
#include <stdarg.h>
void show(int n, ...) {
va_list a; va_start(a, n);
int c = va_arg(a, int);
printf("char is %c\n", c);
va_end(a);
}
int main(void) {
show(1, 'A');
return 0;
}Float staje się double
Argument typu float jest zawsze promowany do double w argumentach wariadycznych. Należy odczytywać go jako double, nigdy jako float.
To jeden z najczęstszych błędów związanych z argumentami wariadycznymi.
#include <stdio.h>
#include <stdarg.h>
void show(int n, ...) {
va_list a; va_start(a, n);
double d = va_arg(a, double);
printf("%.2f\n", d);
va_end(a);
}
int main(void) {
float f = 1.5f;
show(1, f);
return 0;
}Odczytywanie zbyt wielu argumentów
Jeśli kod wywoła va_arg więcej razy, niż argumentów przekazał wywołujący, odczytasz losowe dane ze stosu.
Dlatego tak ważna jest prawidłowa liczba argumentów albo wartownik.
#include <stdio.h>
#include <stdarg.h>
int sum(int n, ...) {
va_list a; va_start(a, n);
int s = 0;
for (int i = 0; i < n; i++) s += va_arg(a, int);
va_end(a);
return s;
}
int main(void) {
printf("%d\n", sum(3, 1, 2, 3));
return 0;
}Wartowniki ze wskaźnikiem NULL wymagają ostrożności
Używanie NULL jako wartownika jest ryzykowne: na niektórych platformach NULL jest wartością 0 typu int, która różni się rozmiarem od wskaźnika.
Należy rzutować ją jawnie, na przykład jako (char *)NULL, aby mieć pewność, że przekazywany jest właściwy typ.
#include <stdio.h>
#include <stdarg.h>
void print_all(const char *first, ...) {
va_list a; va_start(a, first);
const char *s = first;
while (s) { printf("%s\n", s); s = va_arg(a, const char *); }
va_end(a);
}
int main(void) {
print_all("a", "b", (char *)NULL);
return 0;
}Atrybuty formatu kompilatora
GCC i Clang udostępniają __attribute__((format(printf, 1, 2))), aby poinformować kompilator, że funkcja używa formatowania w stylu printf.
Kompilator sprawdza wtedy napisy formatujące w czasie kompilacji, wykrywając wiele błędów.
#include <stdio.h>
#include <stdarg.h>
void logf(const char *fmt, ...)
__attribute__((format(printf, 1, 2)));
void logf(const char *fmt, ...) {
va_list a; va_start(a, fmt);
vprintf(fmt, a);
va_end(a);
}
int main(void) {
logf("%d items\n", 3);
return 0;
}Preferowanie bezpieczniejszych rozwiązań
Ponieważ argumenty wariadyczne są podatne na błędy, w miarę możliwości wybieraj rozwiązania bezpieczne typowo: przekazanie jawnej tablicy, struktury albo parametrów o stałej liczbie.
Argumenty wariadyczne pozostaw do rzeczywistych zastosowań podobnych do printf.
#include <stdio.h>
int sum_array(const int *a, int n) {
int s = 0;
for (int i = 0; i < n; i++) s += a[i];
return s;
}
int main(void) {
int nums[] = {1, 2, 3, 4};
printf("%d\n", sum_array(nums, 4));
return 0;
}Dokumentowanie kontraktu
Ponieważ kompilator nie może egzekwować typów argumentów wariadycznych, jasna dokumentacja jest zabezpieczeniem.
Należy dokładnie określić, jakie typy i ile argumentów musi przekazać wywołujący oraz w jaki sposób kończy się lista.
#include <stdio.h>
#include <stdarg.h>
/* sum_ints(n, ...): pass exactly n int values */
int sum_ints(int n, ...) {
va_list a; va_start(a, n);
int s = 0;
for (int i = 0; i < n; i++) s += va_arg(a, int);
va_end(a);
return s;
}
int main(void) {
printf("%d\n", sum_ints(2, 5, 5));
return 0;
}Dokładne testowanie
Ponieważ błędy mogą pozostać niezauważone, testuj funkcje wariadyczne z wieloma liczbami i typami argumentów.
Przypadki brzegowe, takie jak zero argumentów albo maksymalna ich liczba, często ujawniają pomyłki.
#include <stdio.h>
#include <stdarg.h>
int sum(int n, ...) {
va_list a; va_start(a, n);
int s = 0;
for (int i = 0; i < n; i++) s += va_arg(a, int);
va_end(a);
return s;
}
int main(void) {
printf("%d\n", sum(0));
printf("%d\n", sum(1, 9));
return 0;
}Szybkie sprawdzenie
Sprawdź swoją wiedzę na temat zagrożeń związanych z typami argumentów wariadycznych.
Podsumowanie
Poznałeś zagrożenia związane z funkcjami wariadycznymi:
- Kompilator nie sprawdza typów argumentów wariadycznych.
- Nieprawidłowe typy, liczby argumentów i wartowniki powodują niezdefiniowane działanie.
- Pamiętaj o promocjach: małe liczby całkowite są konwertowane do
int, afloatdodouble. - Używaj atrybutów formatu kompilatora, dokumentuj kontrakt i w miarę możliwości wybieraj rozwiązania bezpieczne typowo.
Często zadawane pytania
Czy lekcja „Problemy z bezpieczeństwem typów” jest bezpłatna?
Tak — pełny tekst „Problemy z bezpieczeństwem typów” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu C Academy, przejdź na CoddyKit PRO. Kurs C Academy zawiera 4 lekcji w sumie.
Co nauczysz się w „Problemy z bezpieczeństwem typów”?
Ryzyko funkcji wariadycznych Ćwiczysz C Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć C Academy?
Nie wymagamy żadnego doświadczenia. C Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 3 z 4.
Ile czasu zajmuje lekcja „Problemy z bezpieczeństwem typów”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji C Academy?
Tak. Każda lekcja C Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Makra stdarg
- Pisanie funkcji podobnych do printf
- Problemy z bezpieczeństwem typów
- Praktyczne przykłady