Isingeniso solimi lwe-C – Umhlahlandlela Owukugcina

Ikhava » Izinhlelo » Isingeniso solimi lwe-C – Umhlahlandlela Owukugcina

Ulimi C lungenye yezinsika eziyisisekelo zezinhlelo zesimanje. Idalwe ngeminyaka yo-1970 ngu-Dennis Ritchie e-Bell Labs, u-C ushiye uphawu olungacimeki emhlabeni wokuthuthukiswa kwesofthiwe. Isingeniso solimi C sibalulekile ekuqondeni ithonya lalo, njengoba izilimi eziningi ezidumile namuhla, njenge-C++, Java, nePython, zizuze njengefa izici ze-syntax nefilosofi yayo.

Kodwa yini eyenza u-C akhetheke kangaka? Okokuqala, ukusebenza kahle kwayo namandla. I-C ivumela abahleli bezinhlelo ukuthi babe nokulawula okunembile ku-hardware, okuyenza ilungele ukuthuthukisa amasistimu wokusebenza, izishayeli zedivayisi, nezinhlelo zokusebenza ezidinga ukusebenza okuphelele. Ngaphezu kwalokho, ubulula bayo obuhlobene nokwamukelwa okubanzi kuyenza ibe isiqalo esihle kakhulu kulabo abafuna ukungena emhlabeni wezinhlelo ezisezingeni eliphansi. Isingeniso ku ulimi C igqamisa lezi zinzuzo futhi ibonise ukuthi kungani isasebenza namuhla.

Isingeniso solimi lwe-C

Kulesi sihloko, sizocubungula izici ezibalulekile zokuqalisa ngolimi C, kusukela ezicini zalo ezibalulekile kuye ekutheni uzithatha kanjani izinyathelo zakho zokuqala ezinhlelweni zika-C noma ngabe ungumuntu othanda ukwazi noma ungumfundi onolwazi ofuna ukunweba ama-horizons akho, lolu hambo lokuya emhlabeni ka-C luzokunikeza isisekelo esiqinile sokuthuthuka kwakho njengomhleli.

Umlando kanye Nokuziphendukela Kwemvelo Kolimi C

Ulimi C aluzange luqhamuke ngokuzenzakalelayo. Ukudalwa kwayo kuxhumene eduze nomlando wekhompiyutha kanye nokuthuthukiswa kwezinhlelo zokusebenza. Dennis Ritchie, esebenza e-AT&T's Bell Laboratories, ithuthukise u-C njengokuvela kolimi lwe-B, oludalwe ngu-Ken Thompson.

U-C wazalwa ngenxa yesidingo solimi olwalusebenza kahle futhi oluphathekayo. Ngaleso sikhathi, izilimi eziningi zokuhlela zazenzelwe ukwakhiwa kwehadiwe ethile, okwenza kube nzima ukuthwala amakhodi. U-C weqe kulo mkhawulo, evumela ukuthi kubhalwe izinhlelo ezingahlanganiswa futhi zisebenze ezinhlotsheni ezahlukene zemishini enoshintsho oluncane.

Ingqophamlando ebalulekile emlandweni ka-C kwaba ukusetshenziswa kwayo ukubhala kabusha incwadi Isistimu yokusebenza ye-UNIX. Lesi sinyathelo sabonisa amandla nokuguquguquka kolimi, silusungula njengethuluzi eliyisisekelo lokuthuthukiswa kwezinhlelo.

Ngokuhamba kweminyaka, i-C iye yavela ngamazinga amaningana:

1. I-K&R C: Inguqulo yoqobo echazwe encwadini ethi “Ulimi Lohlelo Lwe-C” ka-Brian Kernighan no-Dennis Ritchie.
2. I-ANSI C (C89/C90): Ukumiswa okusemthethweni kokuqala kolimi.
3. I-C99: Sethule izici ezintsha njengohlobo lwe-_bool nokusekelwa kwamazwana omugqa owodwa.
4. I-C11: Usekelo olungeziwe lokuthuthukisa izinhlelo ezinemicu eminingi nokuphepha.
5. I-C17: Inguqulo yakamuva kakhulu, elungisa iziphazamisi futhi icacise izinto ezingaqondakali.

Naphezu kweminyaka yayo, i-C isewulimi olubalulekile ekuthuthukisweni kwesofthiwe yesimanje. Ithonya layo lidlulela ngalé kwalo, njengoba liye laba isisekelo sokuthuthukiswa kwabanye. izilimi ezidumile ezifana ne-C++, Objective-C, futhi ngokwezinga elithile, i-Java ne-C#.

Izici ezibalulekile ze-C

Ulimi C luhlukaniswa ngezici ezimbalwa ezilugcine lusebenza amashumi eminyaka. Ukuqonda lezi zici kubalulekile kunoma yimuphi umhleli ongena emhlabeni ka-C.

1. Ukusebenza kahle: C ivumela ukulawula okunembile phezu kwehadiwe, okuholela ezinhlelweni ezisebenza kahle kakhulu. Lesi sici siyenza ilungele izinhlelo zokusebenza ezidinga ukusebenza okuphezulu.
2. Ukuphatheka: Izinhlelo ezibhalwe ngo-C zingahlanganiswa futhi zisebenze ezisekelweni ezihlukene ezinoshintsho oluncane, okwenza kube lula ukuthuthukiswa kwesoftware yesikhulumi.
3. Ukuvumelana nezimo: C inikeza isethi yezici ezivumela abahleli bezinhlelo ukuxazulula izinkinga ngezindlela ezihlukahlukene. Lokhu kuvumelana nezimo, nakuba kunamandla, nakho kudinga isiyalo ngasohlangothini lomhleli.
4. Ukufinyelela kwezinga eliphansi: C ivumela ukushintshwa okuqondile kwememori namabhithi, okubalulekile ekuthuthukiseni amasistimu okusebenza nezishayeli zedivayisi.
5. I-syntax emfushane: I-syntax ye-C ilula futhi iqondile, okwenza kube lula ukufunda nokufunda.
6. Umtapo wolwazi ojwayelekile: I-C iza nomtapo wolwazi ojwayelekile ohlinzeka ngemisebenzi yemisebenzi evamile njengokufakwayo/okuphumayo, ukukhohlisa kwezintambo, nokusebenza kwezibalo.
7. Usekelo lwezinhlelo ezihleliwe: U-C ukhuthaza indlela ye-modular yokuhlela, evumela izinkinga eziyinkimbinkimbi ukuba zihlukaniswe zibe izingxenye ezilawulekayo.

Lezi zici zenza u-C abe ulimi oluguquguqukayo, olukwazi ukuzivumelanisa nezinhlelo eziningi ezahlukene, kusukela kumasistimu ashumekiwe kuya ezinhlelweni zokusebenza ezisebenza kahle.

Imvelo Ethuthukisiwe ka-C

Ukuze uqale ukuhlela ngo-C, uzodinga ukumisa indawo efanelekile yokuthuthukisa. Lokhu kuhilela ukukhetha nokumisa umdidiyeli kanye nomhleli wombhalo noma Indawo Yokuthuthukisa Edidiyelwe (IDE).

C Abahlanganisi

Inhlanganisela iyithuluzi elibalulekile elihumusha ikhodi yakho C ngolimi umshini osebenzisekayo. Abanye abadidiyeli abadumile yilaba:

1. I-GCC (GNU Compiler Collection): Imahhala, umthombo ovulekile futhi isetshenziswa kabanzi ezinhlelweni ze-Unix ne-Linux.
2. klabalasa: Ingxenye yephrojekthi ye-LLVM, inikeza imilayezo yephutha ecacile futhi yaziwa ngesivinini sayo.
3. IMicrosoft Visual C ++: Iza ihlanganiswe ne-Visual Studio futhi isetshenziswa kakhulu ezindaweni zeWindows.

Izihleli Zombhalo kanye nama-IDE

Ungabhala ikhodi C kunoma yimuphi umhleli wombhalo, kodwa i-IDE enhle ingathuthukisa kakhulu ukukhiqiza kwakho. Ezinye izinketho ezidumile yilezi:

1. I-Visual Studio Code: Umhleli wekhodi wamahhala futhi owenzeka ngokwezifiso kakhulu onokusekelwa okuhle kakhulu kwe-C.
2. Ikhodi :: Amabhulokhi: I-IDE ye-cross-platform eklanyelwe ngokukhethekile i-C ne-C++.
3. I-CLion: I-IDE enamandla ethuthukiswe ngabakwa-JetBrains, ewusizo ikakhulukazi kumaphrojekthi amakhulu.

Ukusetha indawo yakho:

1. Faka isihlanganisi (isibonelo, i-GCC ku-Linux noma i-MinGW ku-Windows).
2. Khetha futhi ufake umhleli wombhalo noma i-IDE.
3. Lungiselela umhleli/IDE yakho ukuze usebenzise isihlanganisi esifakiwe.
4. Bhala uhlelo lwakho lokuqala "Sawubona, mhlaba!" ukuze uqinisekise ukuthi konke kusebenza kahle!

#include <stdio.h>

int main() {
    printf("¡Hola, mundo!\n");
    return 0;
}

Ngokumiswa kwendawo yakho, usukulungele ukungena emhlabeni othakazelisayo wezinhlelo ze-C.

I-Syntax Eyisisekelo kanye Nesakhiwo Sohlelo C

I-syntax ye-C iyisisekelo okwakhelwa kuso izinhlelo eziyinkimbinkimbi. Ukuqonda i isakhiwo esiyisisekelo sohlelo ngo-C kubalulekile kunoma yimuphi umhleli oqala ngalolu limi.

Isakhiwo Esiyisisekelo

Uhlelo C luvamise ukuba nesakhiwo esilandelayo:

#include <stdio.h>

int main() {
    // Tu código aquí
    return 0;
}

Ake sihlukanise lesi sakhiwo:

1. I-Preprocessor Directives: Imigqa eqala ngayo # yiziqondiso ze-preprocessor. #include <stdio.h> kufaka phakathi umtapo wolwazi ojwayelekile wokufakwayo/okukhiphayo.
2. main() umsebenzi: Lonke uhlelo C kumele lube nomsebenzi main(). Yindawo yokungena yohlelo.
3. Okhiye {}: Bahlukanisa amabhlogo wekhodi.
4. Comentarios: Ziyasetshenziswa // ukuphawula komugqa owodwa kanye /* */ ukuphawula kwe-multiline.
5. Izigwebo: Sonke isitatimende ku-C siphetha ngesemicolon (;).

Izakhi Eziyinhloko Ze-syntactic

1. Izinkomba: Amagama okuguquguqukayo, imisebenzi, njll. Kufanele aqale ngohlamvu noma ama-underscore.
2. Amagama agqamile: Amagama agodliwe afana int, if, while, ezinencazelo ekhethekile ku-C.
3. Opharetha: Izimpawu ezenza imisebenzi, njenge +, -, *, /.
4. Literals: Amanani ahlala njalo njengezinombolo noma iyunithi yezinhlamvu zombhalo.

Isibonelo esisebenzayo

Ake sibheke isibonelo esihlanganisa izakhi ezimbalwa ze-syntactic:

#include <stdio.h>

int main() {
    int edad = 25;  // Declaración e inicialización de variable

    if (edad >= 18) {
        printf("Eres mayor de edad.\n");
    } else {
        printf("Eres menor de edad.\n");
    }

    return 0;
}

Lolu hlelo lubonisa isimemezelo esiguquguqukayo, ukusetshenziswa okunemibandela, kanye nomsebenzi printf() ukuphrinta kukhonsoli.

Ukwenza kahle i-syntax eyisisekelo ye-C kuyisinyathelo sokuqala sokubhala izinhlelo ezisebenzayo nezisebenza kahle. Njengoba uqhubeka, uzothola ukuthi le syntax ebonakala ilula ikuvumela ukuthi wakhe izakhiwo zokuhlela eziyinkimbinkimbi nezinamandla.

Okuguquguqukayo, Izinhlobo Zedatha kanye nama-Opharetha ku-C

Ku-C, okuguquguqukayo yiziqukathi zokugcina idatha, izinhlobo zedatha zichaza ukuthi yiluphi uhlobo lolwazi oluguquguqukayo olungalubamba, futhi ama-opharetha akuvumela ukuthi ulawule le datha. Ukuqonda lezi imiqondo ibalulekile ezinhlelweni ngempumelelo ku-C.

eziguquguqukayo

Ku-C, kufanele umemezele okuguquguqukayo ngaphambi kokukusebenzisa, ucacise uhlobo lwayo. Ngokwesibonelo:

int edad;
float altura;
char inicial;

Ungaphinda uqalise okuguquguqukayo ngokuwamemezela:

int edad = 25;
float altura = 1.75;
char inicial = 'J';

Izinhlobo Zedatha Eyisisekelo

I-C inikeza izinhlobo ezimbalwa zedatha yakudala:

1. Int: Ngezinombolo.
2. float: Ngezinombolo zedesimali ezinembayo.
3. double: Ukuze uthole izinombolo zedesimali ezinembayo.
4. inqola: Okwabalingisi abangabodwa.

Ngaphezu kwalokho, kukhona modifiers ezifana short, long, unsigned engasetshenziswa kulezi zinhlobo eziyisisekelo.

Opharetha

I-C inikeza ama-opharetha ahlukahlukene ukuze asebenzise idatha:

1. izibalo: +, -, *, /, % (imojuli)
2. Ezobudlelwano: ==, !=, <, >, <=, >=
3. okunengqondo: && (FUTHI), || (NOMA), ! (HHAYI)
4. isabelo: =, +=, -=, *=, /=
5. Khuphula/Yehlisa: ++, --
6. Kancane kancane: &, |, ^, ~, <<, >>

Isibonelo esisebenzayo

Ake sibheke isibonelo esisebenzisa okuguquguqukayo, izinhlobo ezahlukene zedatha, nama-opharetha:

#include <stdio.h>

int main() {
    int a = 10, b = 3;
    float resultado;

    resultado = (float)a / b;  // Casting para obtener resultado decimal

    printf("a + b = %d\n", a + b);
    printf("a - b = %d\n", a - b);
    printf("a * b = %d\n", a * b);
    printf("a / b = %.2f\n", resultado);

    if (a > b && a != 5) {
        printf("a es mayor que b y no es igual a 5\n");
    }

    return 0;
}

Lolu hlelo lubonisa ukusetshenziswa kwezinto eziguquguqukayo zezinhlobo ezahlukene, ukusebenza kwe-arithmetic, ukusakaza, kanye nama-opharetha anengqondo nahlobene.

Ukuqonda indlela yokusingatha okuguquguqukayo, izinhlobo zedatha, kanye nabaqhubi kubalulekile ekubhaleni izinhlelo ezisebenzayo ze-C Le miqondo yakha isisekelo lapho kwakhiwe khona izinhlaka zezinhlelo eziyinkimbinkimbi.

Ukulawula Ukugeleza: Imibandela namaluphu

Ukulawula ukugeleza kubalulekile ezinhlelweni, njengoba kuvumela izinhlelo zethu ukwenza izinqumo nokuphinda izenzo. Ku-C, lokhu kufinyelelwa ngokuyinhloko ngokwakhiwa okunemibandela namaluphu.

Izakhiwo ezinemibandela

Izakhiwo ezinemibandela zikuvumela ukuthi usebenzise amabhlogo ahlukene wekhodi ngokusekelwe ezimeni ezithile.

uma-okunye

Isakhiwo if-else iyisisekelo kakhulu:

if (condición) {
    // Código si la condición es verdadera
} else {
    // Código si la condición es falsa
}

Ungasebenzisa futhi else if ngezimo eziningi:

if (condición1) {
    // Código si condición1 es verdadera
} else if (condición2) {
    // Código si condición2 es verdadera
} else {
    // Código si ninguna condición es verdadera
}

switch

Isakhiwo switch Kuwusizo uma unamacala amaningi asuselwa enanini lokuguquguquka:

switch (variable) {
    case valor1:
        // Código para valor1
        break;
    case valor2:
        // Código para valor2
        break;
    default:
        // Código si no coincide ningún caso
}

Izihibe

Amaluphu akuvumela ukuthi uphinde umugqa wekhodi izikhathi eziningi.

ngoba

Iluphu for Kuhle uma wazi inombolo yokuphindaphinda:

for (inicialización; condición; incremento) {
    // Código a repetir
}

ngenkathi

Iluphu while Yenziwa ngenkathi umbandela uyiqiniso:

while (condición) {
    // Código a repetir
}

yenza-ngenkathi

Okufanayo ne- while, kodwa iqinisekisa ukuthi ikhodi isetshenziswa okungenani kanye:

do {
    // Código a repetir
} while (condición);

Isibonelo esisebenzayo

Ake sibheke isibonelo esihlanganisa izimo nezihibe:

#include <stdio.h>

int main() {
    int numero;

    printf("Ingresa un número entre 1 y 10: ");

        scanf("%d", &numero);

    if (numero < 1 || numero > 10) {
        printf("Número fuera de rango.\n");
    } else {
        printf("Tabla de multiplicar del %d:\n", numero);
        for (int i = 1; i <= 10; i++) {
            printf("%d x %d = %d\n", numero, i, numero * i);
        }
    }

    return 0;
 

Lolu hlelo lubonisa ukusetshenziswa kwe if-else ukuqinisekisa okokufaka komsebenzisi kanye neluphu for ukwenza ithebula lokuphindaphinda. Ihlanganisa ngempumelelo ukulawulwa kokugeleza okunemibandela nokuphindaphinda.

Ukwenza kahle lezi zakhiwo zokulawula ukugeleza kubalulekile ekudaleni izinhlelo eziguquguqukayo neziguqukayo ku-C. Zikuvumela ukuthi udale ingqondo eyinkimbinkimbi futhi uphathe izimo ezihlukene ezinhlelweni zakho zokusebenza.

Imisebenzi kanye neModularity ku-C

Imisebenzi amabhulokhi ekhodi asebenziseka kabusha enza imisebenzi ethile. Zibalulekile ohlelweni lwe-modular, okukuvumela ukuthi uhlukanise izinkinga eziyinkimbinkimbi zibe izingxenye ezilawulekayo. Ku-C, imisebenzi ibaluleke kakhulu ukugcina ikhodi ihlelekile futhi isebenza kahle.

Isakhiwo Somsebenzi

Umsebenzi kokuthi C unokwakheka okujwayelekile okulandelayo:

tipo_retorno nombre_funcion(tipo_parametro1 parametro1, tipo_parametro2 parametro2, ...) {
    // Cuerpo de la función
    return valor;
}

• tipo_retorno: Iwuhlobo lwedatha olubuyiselwa umsebenzi (usebenzisa void uma ingabuyisi lutho).
• nombre_funcion: Kuyisihlonzi somsebenzi.
• parametros: Lawa amanani atholwa umsebenzi (angaba uziro noma ngaphezulu).

Isimemezelo vs Incazelo

Ku-C, kuvamile ukumemezela umsebenzi ngaphambi kokuwuchaza:

// Declaración (prototipo)
int suma(int a, int b);

int main() {
    int resultado = suma(5, 3);
    printf("Resultado: %d\n", resultado);
    return 0;
}

// Definición
int suma(int a, int b) {
    return a + b;
}

Lo mkhuba ikuvumela ukuthi usebenzise imisebenzi ngaphambi kwencazelo yayo ephelele, ewusizo kumaphrojekthi amakhulu.

Amapharamitha kanye Namanani Wokubuyisela

Imisebenzi ingathatha amapharamitha futhi ibuyisele amanani:

int cuadrado(int x) {
    return x * x;
}

void saludar(char* nombre) {
    printf("Hola, %s!\n", nombre);
}

Imisebenzi Kulabhulali Ejwayelekile

C inikeza imisebenzi eminingi ewusizo kulabhulali yayo evamile. Ngokwesibonelo:

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

int main() {
    double numero = 16.0;
    double raiz = sqrt(numero);
    printf("La raíz cuadrada de %.2f es %.2f\n", numero, raiz);
    return 0;
}

I-Modularity kanye ne-Code Organization

Imisebenzi iwukhiye wemodularity ku-C. Ivumela:

1. Ukusetshenziswa kabusha kwekhodi: Bhala kanye, sebenzisa izikhathi eziningi.
2. Isifinyezo: Fihla imininingwane yokusebenzisa.
3. Ukugcineka: Kwenza kube lula ukubuyekeza nokususa amaphutha.
4. Ukufundeka: Yenza ikhodi iqondeke kalula.

Isibonelo esisebenzayo

Ake sibheke isibonelo esibonisa ukusetshenziswa kwemisebenzi ukudala uhlelo lwe-modular:

#include <stdio.h>

// Declaraciones de funciones
float celsius_a_fahrenheit(float celsius);
float fahrenheit_a_celsius(float fahrenheit);
void mostrar_menu();

int main() {
    int opcion;
    float temperatura;

    do {
        mostrar_menu();
        scanf("%d", &opcion);

        switch(opcion) {
            case 1:
                printf("Ingrese temperatura en Celsius: ");
                scanf("%f", &temperatura);
                printf("%.2f°C es igual a %.2f°F\n", temperatura, celsius_a_fahrenheit(temperatura));
                break;
            case 2:
                printf("Ingrese temperatura en Fahrenheit: ");
                scanf("%f", &temperatura);
                printf("%.2f°F es igual a %.2f°C\n", temperatura, fahrenheit_a_celsius(temperatura));
                break;
            case 3:
                printf("Saliendo del programa...\n");
                break;
            default:
                printf("Opción no válida\n");
        }
    } while(opcion != 3);

    return 0;
}

// Definiciones de funciones
float celsius_a_fahrenheit(float celsius) {
    return (celsius * 9/5) + 32;
}

float fahrenheit_a_celsius(float fahrenheit) {
    return (fahrenheit - 32) * 5/9;
}

void mostrar_menu() {
    printf("\nConversor de Temperatura\n");
    printf("1. Celsius a Fahrenheit\n");
    printf("2. Fahrenheit a Celsius\n");
    printf("3. Salir\n");
    printf("Elija una opción: ");
}

Lolu hlelo lubonisa ukuthi imisebenzi ingasetshenziswa kanjani ukuze kwakhiwe ikhodi ehleleke kakhudlwana negcinekayo. Umsebenzi ngamunye unomthwalo wemfanelo othize, okwenza uhlelo oluyinhloko luhlanzeke futhi luqondakala kangcono.

Ukusetshenziswa ngempumelelo kwemisebenzi kubalulekile ekubhaleni izinhlelo ze-C ezakhiwe kahle nezigcinekayo. Njengoba amaphrojekthi akho ekhula ngobunkimbinkimbi, ikhono lokwephula ikhodi yakho libe yimisebenzi yamamojula lizoba yigugu kakhulu.

Izikhombisi kanye Nokuphathwa Kwenkumbulo

Izikhombisi zingomunye wemiqondo enamandla kakhulu futhi evame ukuba yinselele ku-C. Zinikeza ukulawula okuqondile phezu kwenkumbulo futhi ziyisisekelo ekusebenzeni okuningi okuthuthukile. Ukuqonda izinkomba kubalulekile ekuqondeni u-C.

Ziyini Izikhombi?

I-pointer iwukuguquguquka okugcina ikheli lememori lokunye okuguquguqukayo. Ngamanye amazwi, "ikhomba" indawo yocezu lwedatha enkumbulweni.

Ukumemezela nokusebenzisa Izikhombisi

Ukumemezela isikhombisi, kusetshenziswe opharetha *:

int *ptr;  // Declara un puntero a un entero
int numero = 42;
ptr = №  // Asigna la dirección de 'numero' a 'ptr'

Ukufinyelela inani elikhonjwe yisikhombisi, kusetshenziswa i-opharetha yereferensi. *:

printf("Valor: %d\n", *ptr);  // Imprime 42

I-Pointer Arithmetic

C ivumela ukuthi imisebenzi ye-arithmetic yenziwe ezikhombi:

int arr[] = {10, 20, 30, 40};
int *p = arr;

printf("%d\n", *p);     // Imprime 10
printf("%d\n", *(p+1)); // Imprime 20

Izikhombisi nama-Arrays

Ku-C, amalungu afanayo ahlobene eduze nezikhombisi:

int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr;  // ptr apunta al primer elemento de arr

for (int i = 0; i < 5; i++) {
    printf("%d ", *(ptr + i));  // Imprime los elementos del array
}

Dynamic Memory Management

C ikuvumela ukuthi unikeze inkumbulo ngokuguquguqukayo ngesikhathi sokusebenza usebenzisa imisebenzi efana malloc(), calloc(), futhi realloc(). Le nkumbulo kufanele ikhishwe ngesandla nge free().

#include <stdlib.h>

int *ptr = (int*)malloc(5 * sizeof(int));  // Asigna memoria para 5 enteros

if (ptr == NULL) {
    printf("Error: no se pudo asignar memoria\n");
    return 1;
}

// Usar la memoria...

free(ptr);  // Liberar la memoria cuando ya no se necesita
ptr = NULL; // Buena práctica: asignar NULL después de liberar

Izikhombi Zomsebenzi

I-C ikuvumela ukuthi ube nezikhombisi zokusebenza, eziwusizo kuma-callbacks nohlelo oluqhutshwa umcimbi:

int suma(int a, int b) { return a + b; }
int resta(int a, int b) { return a - b; }

int (*operacion)(int, int);  // Declara un puntero a función

operacion = suma;
printf("Resultado: %d\n", operacion(5, 3));  // Imprime 8

operacion = resta;
printf("Resultado: %d\n", operacion(5, 3));  // Imprime 2

Izingozi Nemikhuba Emihle

Izikhombisi zinamandla, kodwa zingaba yingozi uma zisetshenziswe ngokungalungile:

1. Njalo qalisa izikhombi.
2. Bheka ukuthi ngabe malloc() kanye nemisebenzi efanayo ibe yimpumelelo.
3. Inkumbulo eguquguqukayo yamahhala uma ingasadingeki.
4. Qaphela ngezikhombi ezilengayo (ezikhomba kumemori ekhululiwe).
5. Ivimbela ukuchichima kwebhafa.

Isibonelo esisebenzayo

Ake sibheke isibonelo esisebenzisa izinkomba ukuze kusetshenziswe uhlu oluxhumeke olulodwa:

#include <stdio.h>
#include <stdlib.h>

struct Nodo {
    int dato;
    struct Nodo* siguiente;
};

void insertar_al_inicio(struct Nodo** cabeza, int nuevo_dato) {
    struct Nodo* nuevo_nodo = (struct Nodo*)malloc(sizeof(struct Nodo));
    nuevo_nodo->dato = nuevo_dato;
    nuevo_nodo->siguiente = *cabeza;
    *cabeza = nuevo_nodo;
}

void imprimir_lista(struct Nodo* nodo) {
    while (nodo != NULL) {
        printf("%d ", nodo->dato);
        nodo = nodo->siguiente;
    }
    printf("\n");
}

int main() {
    struct Nodo* cabeza = NULL;

    insertar_al_inicio(&cabeza, 3);
    insertar_al_inicio(&cabeza, 2);
    insertar_al_inicio(&cabeza, 1);

    printf("Lista: ");
    imprimir_lista(cabeza);

    // Liberar memoria
    struct Nodo* actual = cabeza;
    struct Nodo* siguiente;
    while (actual != NULL) {
        siguiente = actual->siguiente;
        free(actual);
        actual = siguiente;
    }

    return 0;
}

Lesi sibonelo sibonisa ukusetshenziswa kwezikhombisi ukuze kudalwe futhi kusetshenziswe uhlaka lwedatha oluguqukayo. Izikhombisi zikuvumela ukuthi udale ama-node axhunyiwe futhi uzulazule kuwo.

Izikhombisi-ndlela kanye nokuphathwa kwenkumbulo kubalulekile ekusebenziseni amandla aphelele ka-C. Nakuba zingaba inselele ekuqaleni, ngokuzijwayeza nokunakekela, ziba ithuluzi elibalulekile kunqolobane yakho yezinhlelo.

Izakhiwo Zedatha ku-C

I-Las izakhiwo zedatha Zibalulekile ezinhlelweni, njengoba zivumela idatha ukuthi ihlelwe futhi isetshenziswe kahle. I-C inikeza izindlela ezimbalwa zokudala izakhiwo zedatha, kusukela kwelula kakhulu kuye kweyinkimbinkimbi kakhulu.

I-Arrays

Izinhlu ziyisakhiwo sedatha eyisisekelo kakhulu ku-C. Avumela izici eziningi zohlobo olufanayo ukuthi zigcinwe ezindaweni zememori ezixhumene.

int numeros[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
    printf("%d ", numeros[i]);
}

Izakhiwo (isakhiwo)

Izakhiwo zikuvumela ukuthi uqoqe izinhlobo ezahlukene zedatha ngaphansi kwegama elilodwa.

struct Persona {
    char nombre[50];
    int edad;
    float altura;
};

struct Persona p1 = {"Juan", 25, 1.75};
printf("Nombre: %s, Edad: %d, Altura: %.2f\n", p1.nombre, p1.edad, p1.altura);

Izinyunyana (inyunyana)

Izinyunyana ziyafana nezakhiwo, kodwa wonke amalungu azo abelana ngendawo yenkumbulo efanayo.

union Dato {
    int i;
    float f;
    char str[20];
};

union Dato d;
d.i = 10;
printf("d.i: %d\n", d.i);
strcpy(d.str, "Hola");
printf("d.str: %s\n", d.str);

Izibalo (enum)

Izibalo zikuvumela ukuthi uchaze uhlobo lwedatha olunesethi engaguquki yama-constants.

enum DiaSemana {LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO};
enum DiaSemana hoy = MIERCOLES;
printf("Hoy es el día %d de la semana\n", hoy + 1);

Izakhiwo Zedatha Enamandla

I-C ikuvumela ukuthi udale izakhiwo zedatha eziguquguqukayo usebenzisa izinkomba kanye nokwabiwa kwememori okuguquguqukayo.

Uhlu Oluxhunyiwe

struct Nodo {
    int dato;
    struct Nodo* siguiente;
};

struct Nodo* crearNodo(int dato) {
    struct Nodo* nuevoNodo = (struct Nodo*)malloc(sizeof(struct Nodo));
    nuevoNodo->dato = dato;
    nuevoNodo->siguiente = NULL;
    return nuevoNodo;
}

Isitaki

#define MAX 100
struct Pila {
    int items[MAX];
    int top;
};

void inicializarPila(struct Pila* p) {
    p->top = -1;
}

void push(struct Pila* p, int x) {
    if (p->top < MAX - 1) {
        p->items[++(p->top)] = x;
    }
}

int pop(struct Pila* p) {
    if (p->top >= 0) {
        return p->items[(p->top)--];
    }
    return -1;
}

Ulayini

struct Nodo {
    int dato;
    struct Nodo* siguiente;
};

struct Cola {
    struct Nodo *frente, *atras;
};

void inicializarCola(struct Cola* q) {
    q->frente = q->atras = NULL;
}

void encolar(struct Cola* q, int x) {
    struct Nodo* temp = crearNodo(x);
    if (q->atras == NULL) {
        q->frente = q->atras = temp;
        return;
    }
    q->atras->siguiente = temp;
    q->atras = temp;
}

int desencolar(struct Cola* q) {
    if (q->frente == NULL)
        return -1;
    int dato = q->frente->dato;
    struct Nodo* temp = q->frente;
    q->frente = q->frente->siguiente;
    if (q->frente == NULL)
        q->atras = NULL;
    free(temp);
    return dato;
}

Isibonelo Esisebenzayo: Isihlahla Kanambambili

Ake sibheke isibonelo esiyinkimbinkimbi yesakhiwo sedatha: a kanambambili search tree.

#include <stdlib.h>

struct Nodo {
    int dato;
    struct Nodo *izquierda, *derecha;
};

struct Nodo* crearNodo(int dato) {
    struct Nodo* nuevoNodo = (struct Nodo*)malloc(sizeof(struct Nodo));
    nuevoNodo->dato = dato;
    nuevoNodo->izquierda = nuevoNodo->derecha = NULL;
    return nuevoNodo;
}

struct Nodo* insertar(struct Nodo* raiz, int dato) {
    if (raiz == NULL) return crearNodo(dato);

    if (dato < raiz->dato)
        raiz->izquierda = insertar(raiz->izquierda, dato);
    else if (dato > raiz->dato)
        raiz->derecha = insertar(raiz->derecha, dato);

    return raiz;
}

void inorden(struct Nodo* raiz) {
    if (raiz != NULL) {
        inorden(raiz->izquierda);
        printf("%d ", raiz->dato);
        inorden(raiz->derecha);
    }
}

int main() {
    struct Nodo* raiz = NULL;
    raiz = insertar(raiz, 50);
    insertar(raiz, 30);
    insertar(raiz, 20);
    insertar(raiz, 40);
    insertar(raiz, 70);
    insertar(raiz, 60);
    insertar(raiz, 80);

    printf("Recorrido inorden del árbol: ");
    inorden(raiz);
    printf("\n");

    return 0;
}

Lesi sibonelo sibonisa ukuqaliswa kwesihlahla sosesho esinambambili, isakhiwo sedatha esithuthuke kakhulu esisebenzisa izikhombi nokwabiwa kwenkumbulo okuguquguqukayo.

I-Las Izakhiwo zedatha zibalulekile ukuze uhlele kahle futhi uphathe idatha ku-C. Kusukela ku-array elula kuya ezakhiweni eziyinkimbinkimbi njengezihlahla, ukwazi lezi zakhiwo kuzokuvumela ukuthi uxazulule izinkinga zokuhlela ngempumelelo.

Okokufaka/Okukhiphayo kanye Nokuphathwa Kwefayela

Okokufaka/okuphumayo (I/O) nokuphathwa kwefayela kuyizingxenye ezibalulekile zohlelo lwe-C, okuvumela izinhlelo ukuthi zihlanganyele nomsebenzisi futhi zigcine noma zibuyise idatha ngokuqhubekayo.

Okokufaka/Okukhiphayo Okujwayelekile

C inikeza imisebenzi kulabhulali <stdio.h> okokufaka/okuphumayo okujwayelekile:

Phuma

• printf(): Ukuze uphrinte umbhalo ofomethiwe kukhonsoli.
• puts(): Ukuphrinta iyunithi yezinhlamvu elandelwa umugqa omusha.
• putchar(): Ukuphrinta uhlamvu olulodwa.

printf("Hola, %s!\n", "mundo");
puts("Esto es una línea");
putchar('A');

entry

• scanf(): Ukuze ufunde okokufaka okufomethiweyo kukhibhodi.
• gets() (ephelelwe yisikhathi) futhi fgets(): Ukufunda umugqa wombhalo.
• getchar(): Ukufunda uhlamvu olulodwa.

int numero;
char nombre[50];

printf("Ingrese un número: ");
scanf("%d", &numero);

printf("Ingrese su nombre: ");
fgets(nombre, sizeof(nombre), stdin);

Ukuphathwa kwefayela

C ivumela ukusebenza ngamafayela okugcinwa kwedatha okuqhubekayo:

Vula futhi Vala Amafayela

FILE *archivo;
archivo = fopen("ejemplo.txt", "w");  // Abrir para escritura
if (archivo == NULL) {
    printf("Error al abrir el archivo\n");
    return 1;
}
// Usar el archivo...
fclose(archivo);  // Cerrar el archivo

Ukubhala Ezinqolobaneni

• fprintf(): Ibhala umbhalo ofomethiwe efayeleni.
• fputs(): Bhala iyunithi yezinhlamvu efayeleni.
• fputc(): Bhala uhlamvu efayeleni.

fprintf(archivo, "Número: %d\n", 42);
fputs("Hola, archivo!\n", archivo);
fputc('X', archivo);

Ukufunda Amafayela

• fscanf(): Ifunda idatha efomethiwe efayelini.
• fgets(): Funda umugqa efayelini.
• fgetc(): Funda uhlamvu efayelini.

int num;
char linea[100];

fscanf(archivo, "%d", &num);
fgets(linea, sizeof(linea), archivo);
char c = fgetc(archivo);

Isibonelo Esisebenzayo: I-ajenda Elula

Ake sibheke isibonelo esihlanganisa okokufaka/okuphumayo kanye ukuphathwa kwefayela Ukuze udale i-ajenda elula:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NOMBRE 50
#define MAX_TELEFONO 15

struct Contacto {
    char nombre[MAX_NOMBRE];
    char telefono[MAX_TELEFONO];
};

void agregarContacto(FILE *archivo) {
    struct Contacto nuevo;
    printf("Nombre: ");
    fgets(nuevo.nombre, MAX_NOMBRE, stdin);
    nuevo.nombre[strcspn(nuevo.nombre, "\n")] = 0;
    printf("Teléfono: ");
    fgets(nuevo.telefono, MAX_TELEFONO, stdin);
    nuevo.telefono[strcspn(nuevo.telefono, "\n")] = 0;

    fwrite(&nuevo, sizeof(struct Contacto), 1, archivo);
    printf("Contacto agregado.\n");
}

void mostrarContactos(FILE *archivo) {
    struct Contacto c;
    rewind(archivo);
    while(fread(&c, sizeof(struct Contacto), 1, archivo) == 1) {
        printf("Nombre: %s, Teléfono: %s\n", c.nombre, c.telefono);
    }
}

int main() {
    FILE *archivo;
    int opcion;

    archivo = fopen("agenda.dat", "ab+");
    if (archivo == NULL) {
        printf("Error al abrir el archivo.\n");
        return 1;
    }

    do {
        printf("\n1. Agregar contacto\n");
        printf("2. Mostrar contactos\n");
        printf("3. Salir\n");
        printf("Elija una opción: ");
        scanf("%d", &opcion);
        getchar(); // Limpiar el buffer

        switch(opcion) {
            case 1:
                agregarContacto(archivo);
                break;
            case 2:
                mostrarContactos(archivo);
                break;
            case 3:
                printf("Saliendo...\n");
                break;
            default:
                printf("Opción no válida.\n");
        }
    } while(opcion != 3);

    fclose(archivo);
    return 0;
}

Lesi sibonelo sibonisa indlela yokusebenzisa okokufaka/okuphumayo okujwayelekile ukuze uxhumane nomsebenzisi kanye nendlela yokuphatha amafayela ukuze ugcine idatha ngokuqhubekayo. Incwadi yamakheli ikuvumela ukuthi ungeze oxhumana nabo futhi ubonise abathintwayo abakhona, bonke balondolozwe kufayela kanambambili.

Okokufaka/okuphumayo okusebenzayo nokuphathwa kwamafayela kubalulekile ekudaleni izinhlelo ze-C ezisebenzisana ngempumelelo nomsebenzisi futhi zisingatha idatha ngokuqhubekayo. Lawa makhono abalulekile ekuthuthukiseni izinhlelo zokusebenza eziqinile neziwusizo ku-C.

Imikhuba Emihle kanye Namazinga Okubhala Amakhodi

Ukwamukela imikhuba emihle nokulandela izindinganiso zokubhala ikhodi kubalulekile ekubhaleni ikhodi C ehlanzekile, elondolozekayo, nephumelelayo. Lezi zinqubo azithuthukisi kuphela ukufundeka kwekhodi, kodwa futhi zisiza ukuvimbela amaphutha futhi zenze kube lula ukusebenzisana kumaphrojekthi weqembu.

I-Nomenclature Nesitayela

1. Amagama achazayo: Sebenzisa amagama anencazelo okuguquguqukayo, imisebenzi, nezakhiwo.

   int edad_usuario;  // Bien
   int x;  // Evitar, poco descriptivo
   

2. Izivumelwano Zokuqanjwa Kwamagama:
   • Okuguquguqukayo nemisebenzi: snake_case
   • Okwama-constants: MAYUSCULAS_CON_GUIONES_BAJOS
   • Ngezinhlobo ezichaziwe (typedef): PascalCase
3. Ukuhlehlisa okungaguquki: Sebenzisa izikhala noma amathebhu ngokungashintshi (imvamisa izikhala ezi-4).
4. Umkhawulo Wobude Bomugqa: Gcina imigqa yekhodi ngaphansi kwezinhlamvu ezingu-80-100 ukuze uthuthukise ukufundeka.

Inhlangano Yekhodi

1. Inhloso Yokusebenza:Umsebenzi ngamunye kufanele wenze umsebenzi othile futhi ochazwe kahle.
2. Ukuzijwayeza: Hlukanisa ikhodi ibe amamojula anengqondo futhi uhlukanise amafayela.
3. Amazwana Awusizo: Xoxani ngokuthi kungani, hhayi ngani. Ikhodi kufanele izichaze yona.

   // Calcula el promedio de los elementos del array
   float calcular_promedio(int *arr, int size) {
     // ...
   }
   

4. Ukusebenzisa Constants: Ichaza ama-constants amanani omlingo.

   #define MAX_BUFFER_SIZE 1024
   char buffer[MAX_BUFFER_SIZE];
   

Inkumbulo Nokuphathwa Kwezinsiza

1. Ukuqaliswa Kokuguquguqukayo: Njalo qalisa okuguquguqukayo ngaphambi kokuzisebenzisa.
2. Ukukhishwa Kwenkumbulo: Khulula yonke inkumbulo eyabiwe ngokuguquguqukayo.

   int *ptr = malloc(sizeof(int) * 10);
   // Usar ptr...
   free(ptr);
   ptr = NULL;  // Evita punteros colgantes
   

3. Iphutha Ekuhloleni: Njalo qinisekisa impumelelo yemisebenzi ebalulekile.

   FILE *file = fopen("archivo.txt", "r");
   if (file == NULL) {
     // Manejar el error
   }
   

Ukuphepha Nokuqina

1. Ukuqinisekisa okokufaka: Njalo qinisekisa okokufaka komsebenzisi namapharamitha omsebenzi.
2. Ukusebenzisa i-Type Constants: Isebenzisa const okuguquguqukayo okungafanele kulungiswe.

   void imprimir_array(const int *arr, int size) {
     // ...
   }
   

3. Ukugwema Ukuchichima Kwesigcinalwazi: Sebenzisa izici eziphephile noma hlola imikhawulo.

   char buffer[50];
   snprintf(buffer, sizeof(buffer), "%s", input);  // Seguro
   

Ukuthuthukisa kanye nokusebenza

1. Beka Eqhulwini Ukucaca: Bhala ikhodi ehlanzekile kuqala, lungiselela kuphela uma kunesidingo, kanye nephrofayili kamuva.
2. Ukusetshenziswa Okuphumelelayo Kwezakhiwo Zokulawula: Khetha izakhiwo zokulawula ezifanele kakhulu zomsebenzi ngamunye.
3. Gwema Ukuphindaphinda Ikhodi: Sebenzisa imisebenzi ukuze uhlanganise ukucabanga okuphindaphindayo.

Ikhodi Isibonelo Ukulandela Imikhuba Emihle

Ake sibheke isibonelo esihlanganisa ezimbalwa zale mikhuba emihle:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAX_NAME_LENGTH 50
#define MAX_STUDENTS 100

typedef struct {
    char name[MAX_NAME_LENGTH];
    int age;
    float gpa;
} Student;

void initialize_student(Student *student, const char *name, int age, float gpa) {
    strncpy(student->name, name, MAX_NAME_LENGTH - 1);
    student->name[MAX_NAME_LENGTH - 1] = '\0';
    student->age = age;
    student->gpa = gpa;
}

void print_student(const Student *student) {
    printf("Name: %s, Age: %d, GPA: %.2f\n", student->name, student->age, student->gpa);
}

float calculate_average_gpa(const Student *students, int count) {
    if (count <= 0) return 0.0f;

    float total_gpa = 0.0f;
    for (int i = 0; i < count; i++) {
        total_gpa += students[i].gpa;
    }
    return total_gpa / count;
}

int main() {
    Student students[MAX_STUDENTS];
    int student_count = 0;

    // Adding students
    initialize_student(&students[student_count++], "Alice Smith", 20, 3.8);
    initialize_student(&students[student_count++], "Bob Johnson", 22, 3.5);
    initialize_student(&students[student_count++], "Charlie Brown", 21, 3.9);

    // Printing students
    for (int i = 0; i < student_count; i++) {
        print_student(&students[i]);
    }

    // Calculating and printing average GPA
    float avg_gpa = calculate_average_gpa(students, student_count);
    printf("Average GPA: %.2f\n", avg_gpa);

    return 0;
}

Lesi sibonelo sibonisa imikhuba emihle eminingi:

• Ukusebenzisa ama-constants achaziwe (#define)
• Amagama achazayo okuguquguqukayo nemisebenzi
• Ukusetshenziswa typedef ukuze udale uhlobo lwedatha yangokwezifiso
• Imisebenzi enenjongo eyodwa, echazwe kahle
• Ukusetshenziswa const kumapharamitha okungafanele ashintshwe
• Ukuphatha izintambo ngokuphepha (usebenzisa strncpy nomkhawulo)
• Amazwana awusizo futhi amafushane
• Ihlola izimo zephutha (in calculate_average_gpa)

Ukulandela lezi zinqubo ezihamba phambili nezindinganiso zokubhala ikhodi kuzokusiza ukuthi ubhale ikhodi C ehlanzekile, ephephile, negcinekeka kakhudlwana. Njengoba uthola ulwazi, lezi zinqubo zizoba imvelo yesibili futhi zizothuthukisa kakhulu ikhwalithi yekhodi yakho.

Amathuluzi Okulungisa Amaphutha Nokuthuthukisa

Ukulungisa iphutha kuyingxenye ebalulekile yenqubo yokuthuthukisa isofthiwe ye-C Ukwazi izindlela zokususa iphutha futhi ukwazi amathuluzi atholakalayo kungakongela isikhathi esiningi nokukhungatheka lapho uxazulula inkinga.

Amasu Okulungisa Okuyisisekelo

1. Susa iphutha lokuphrinta: Indlela elula yokwengeza izitatimende printf ukulandelela ukugeleza kohlelo namanani aguquguqukayo.

   printf("Debug: x = %d, y = %d\n", x, y);
   

2. Iziqinisekiso: Sebenzisa i-macro assert ukuhlola izimo okufanele zibe yiqiniso.

   #include <assert.h>
   
   assert(ptr != NULL);  // El programa se detendrá si ptr es NULL
   

3. Ihlanganisa ne-Debug Flags: Sebenzisa amafulegi -g y -Wall lapho uhlanganisa ne-GCC ukuze ufake ulwazi lokususa iphutha futhi unike amandla zonke izixwayiso.

   gcc -g -Wall programa.c -o programa

Amathuluzi Wokususa iphutha

1. I-GDB (GNU Debugger): Ithuluzi lomugqa womyalo onamandla wokulungisa amaphutha wezinhlelo ze-C.

   gdb ./programa
   (gdb) break main
   (gdb) run
   (gdb) next
   (gdb) print variable
   (gdb) continue
   (gdb) quit
   

2. I-Valgrind: Kuhle kakhulu ukuthola ukuvuza kwenkumbulo namanye amaphutha ahlobene nenkumbulo.

   valgrind --leak-check=full ./programa

3. I-IDE ene-Integrated DebuggerAma-IDE afana ne-Visual Studio Code, i-CLion, noma i-Eclipse CDT inikezela ngokusebenzelana kwezithombe zokulungisa iphutha okungenzeka kube enembile kwabanye onjiniyela.

Amasu Okulungisa Okuthuthukile

1. Ukulungisa iphutha: Iwusizo kumasistimu ashumekiwe noma uma uhlelo lusebenza emshinini ohlukile.
2. Ukulungisa ama-Core Dumps: Hlaziya ukulahlwa kwenkumbulo ngemva kokuthi uhlelo luphahlazekile.

   
gdb ./programa core

3. Ukulungisa Amaphutha Izinhlelo Ezifundwe Eziningi: Sebenzisa amathuluzi afana ne-Helgrind (ingxenye ye-Valgrind) ukuze uthole izinkinga zokusebenzisana.

   valgrind --tool=helgrind ./programa_multihilo
   

Amathuluzi Okuhlaziya Aqinile

1. Cppcheck: Ihlaziya ikhodi ngaphandle kokuyenza ukuze kutholwe amaphutha nemikhuba emibi.

   cppcheck --enable=all programa.c
   

2. I-Lint noma i-Splint: Amathuluzi asiza ukuthola amaphutha ohlelo nesitayela.

Ukuthuthukisa kanye nokwenza iphrofayela

1. gprof: Ithuluzi lephrofayela elisiza ukukhomba izingqinamba zokusebenza.

   
   gcc -pg programa.c -o programa
   ./programa
   gprof programa gmon.out > analisis.txt
   

2. i-perf: Ithuluzi lokuhlaziya ukusebenza ezinhlelweni ze-Linux.

   
perf record ./programa
   perf report

Isibonelo Esisebenzayo: Ukulungisa iphutha Uhlelo Olulula

Ake sibheke isibonelo sokuthi singasusa kanjani iphutha ohlelweni olulula ngephutha:

#include <stdio.h>
#include <stdlib.h>

void procesar_array(int *arr, int size) {
 for (int i = 0; i <= size; i++) {  // Error: debería ser i < size
     arr[i] *= 2;
 }
}

int main() {
 int *numeros = malloc(5 * sizeof(int));
 for (int i = 0; i < 5; i++) {
     numeros[i] = i + 1;
 }

 procesar_array(numeros, 5);

 for (int i = 0; i < 5; i++) {
     printf("%d ", numeros[i]);
 }
 printf("\n");

 free(numeros);
 return 0;
}

Lolu hlelo lunesiphazamisi esicashile emsebenzini procesar_array: Iluphu iphindaphinda kanye ngaphezu kwalokho okudingekayo, ibangele ukuchichima kwebhafa.

Izinyathelo zokususa iphutha:

1. Hlanganisa namafulegi okususa iphutha:

   gcc -g -Wall programa.c -o programa
   

2. Gijima noValgrind:

   valgrind ./programa
   

   U-Valgrind cishe uzobika ukufinyelela kwememori okungavumelekile.

3. Ukusebenzisa i-GDB ukuphenya kabanzi:

   gdb ./programa
   (gdb) break procesar_array
   (gdb) run
   (gdb) next
   (gdb) print i
   (gdb) print size
   

4. Uma iphutha selikhonjiwe, lilungise ngokushintsha i <= size a i < size en procesar_array.
5. Hlanganisa futhi uphinde uhlole ukuze uqinisekise ukuthi iphutha lixazululiwe.

Amathiphu Okugcina Okulungisa Amaphutha Okuphumelelayo

1. Phinda ukhiqize Iphutha: Qiniseka ukuthi ungakwazi ukukhiqiza kabusha isiphazamisi ngokungaguquki ngaphambi kokuthi uqale ukulungisa iphutha.
2. Hlukanisa futhi Unqobe: Uma inkinga iyinkimbinkimbi, zama ukuyehlukanisa ube nocezu oluncane lwekhodi.
3. Bheka Izinguquko Zakamuva: Iziphazamisi zivame ukwethulwa ekulungisweni kwakamuva kakhulu.
4. Ungacabangi Lutho: Hlola ngisho nezingxenye zekhodi ocabanga ukuthi zisebenza kahle.
5. Sebenzisa Ukulawulwa KwenguquloAmathuluzi afana ne-Git akuvumela ukuthi ubuyisele kalula izinguquko uma wethula izindaba ezintsha ngenkathi ususa iphutha.
6. Gcina Irekhodi: Bhala phansi izinyathelo ozithathayo ngesikhathi sokulungisa iphutha, ikakhulukazi ezinkingeni ezinzima.
7. Funda emaphutheni: Zonke iziphazamisi ziyithuba lokuthuthukisa eyakho amakhono okuhlela futhi uvimbele amaphutha afanayo esikhathini esizayo.

Ukulungisa iphutha kuwubuciko kanye nesayensi. Ngokuzijwayeza nokusebenzisa ngendlela efanele amathuluzi, uzosebenza kahle kakhulu ekuhlonzeni nasekuxazululeni izinkinga kukhodi yakho C. Khumbula ukuthi ukubekezela nokuphikelela kungukhiye enqubweni yokususa iphutha.

Izicelo Nekusasa Lolimi Lwe-C

Naphezu kweminyaka yalo, ulimi C lusalokhu lunamandla emhlabeni wezinhlelo. Ukusebenza kahle kwayo, ukuphatheka, kanye nokulawulwa kwezinga eliphansi kukugcina kuhambisana emikhakheni eyahlukene. Ake sibheke ezinye izinhlelo zokusebenza zamanje ze-C futhi siqagele ngekusasa layo.

Izinhlelo zokusebenza zamanje ze-C

1. Izinhlelo zokusebenza: U-C uhlala kuwulimi olukhethwayo ekuthuthukisweni kwezinhlelo zokusebenza. I-Linux, i-macOS, ne-Windows inezingxenye ezinkulu zekhodi yazo ebhalwe ku-C.
2. Amasistimu Ashumekiwe:Ngenxa yokusebenza kahle kwayo kanye nokulawula okuphansi, i-C isetshenziswa kakhulu ezinhlelweni ezishumekiwe, kusukela ezintweni zasendlini kuya ezimotweni ezizimele.
3. Ukuthuthukiswa kwemidlalo yevidiyo: Izinjini eziningi zemidlalo namathuluzi okuthuthukisa abhalwe ngo-C noma C++.
4. Yolwazi: Izinhlelo zokuphatha i-database ezifana ne-MySQL ne-PostgreSQL zisetshenziswa ku-C.
5. Abahlanganisi Namathuluzi Okuthuthukisa: Abadidiyeli abaningi, otolika namathuluzi okuthuthukisa abhalwe ngo-C.
6. Izicelo Ezisebenza Kakhulu: C isetshenziswa ezinhlelweni ezidinga ukusebenza okuphezulu, okufana nokulingisa kwesayensi nokucubungula idatha enkulu.
7. Ukuphepha kanye ne-Cryptography: Amalabhulali amaningi okuvikela namathuluzi asetshenziswa ngo-C ngenxa yokusebenza kahle kwawo nokulawula okuphansi.

Ikusasa lika-C

1. Ukuhambisana Okuqhubekayo: Ngaphandle kokuvela kwezilimi ezintsha, u-C uzohlala efanelekile ngenxa yokusebenza kahle kwayo kanye nenani elikhulu lekhodi ekhona.
2. Ukuvela Kwezinga: Ikomidi lokumisa i-C liyaqhubeka nokusebenza ezinguqulweni ezintsha zolimi, lengeza izici zesimanje kuyilapho ligcina ukuhambisana okubuyela emuva.
3. Ukuhlanganiswa ne-New Technologies: U-C uzivumelanisa nezimo ukuze asebenze kangcono ngobuchwepheshe obusafufusa obufana i-quantum computing kanye nobuhlakani bokwenziwa.
4. Ukuthuthukiswa KwezokuphephaUma kubhekwa ukubaluleka kokuphepha kusofthiwe yesimanje, kungenzeka sibone izici eziningi namathuluzi agxile ekubhaleni ikhodi C evikeleke kakhulu.
5. Ukuthuthukiswa Kwezinhlelo Zokusebenzisa Okuphansi: Ngokukhuphuka kwamadivayisi e-IoT kanye nekhompuyutha enqenqemeni, i-C izoqhubeka nokubaluleka ekuthuthukiseni amasistimu awonga ugesi.
6. Ukusebenzisana: U-C uzoqhubeka nokuba "ulimi lweglue", okuvumela ukusebenzisana phakathi kwezilimi nezinhlelo ezahlukene.

Izinselelo Namathuba

1. Ukwazi Ngezinye Izilimi: Izilimi ezifana nokuRust ziyanda ezindaweni ezivame ukubuswa u-C, ikakhulukazi uma kuziwa ekuphepheni kwenkumbulo.
2. Ukwandisa Ukuyinkimbinkimbi Kwezinhlelo: Njengoba amasistimu eba yinkimbinkimbi kakhulu, u-C uzodinga ukuvela ukuze asingathe lobu bunzima ngaphandle kokulahlekelwa ukusebenza kahle kwesici.
3. Imfundo Nokuqeqeshwa: Ukugcina isisekelo esiqinile sabahleli bezinhlelo ze-C kuzobaluleka ekugcineni nasekuthuthukiseni amasistimu abalulekile.
4. Ukulinganisa Ukwenziwa Kwesimanje Nokuhambisana: Inselele eqhubekayo kuzoba ukungeza izici zesimanje ku-C ngaphandle kokuphazamisa ubulula bayo nokuhambisana kwayo emuva.

Isibonelo: C ekuthuthukisweni kwe-IoT

Ake sibheke isibonelo esilula sokuthi u-C ungasetshenziswa kanjani kudivayisi ye-IoT ukufunda inzwa yokushisa nokuthumela idatha:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <linux/i2c-dev.h>

#define I2C_ADDR 0x48  // Dirección I2C del sensor de temperatura

float leer_temperatura(int file) {
    char reg[1] = {0x00};
    char data[2] = {0};

    if (write(file, reg, 1) != 1) {
        perror("Error de escritura en I2C");
        exit(1);
    }

    if (read(file, data, 2) != 2) {
        perror("Error de lectura en I2C");
        exit(1);
    }

    int raw = (data[0] << 8) | data[1];
    float temp = raw / 256.0;
    return temp;
}

int main() {
    int file;
    char *filename = "/dev/i2c-1";

    if ((file = open(filename, O_RDWR)) < 0) {
        perror("Error al abrir el bus I2C");
        exit(1);
    }

    if (ioctl(file, I2C_SLAVE, I2C_ADDR) < 0) {
        perror("Error al acceder al sensor");
        exit(1);
    }

    while (1) {
        float temp = leer_temperatura(file);
        printf("Temperatura: %.2f°C\n", temp);
        sleep(1);  // Esperar 1 segundo antes de la siguiente lectura
    }

    close(file);
    return 0;
}

Lesi sibonelo sibonisa indlela u-C angasetshenziswa ngayo ukuxhumana ngokuqondile nehadiwe kudivayisi ye-IoT, ngokufunda idatha kusuka kunzwa yezinga lokushisa phezu kwebhasi le-I2C.

Isiphetho sesingeniso solimi C

Ulimi lwe-C, naphezu kweminyaka yalo, luhlala luyithuluzi eliyisisekelo emhlabeni wokuthuthukiswa kwesofthiwe. Ukusebenza kahle kwayo, ukuphatheka nokulawula izinga eliphansi kuyenza ingenakuthathelwa indawo ezindaweni eziningi ezibalulekile zobuchwepheshe. Nakuba ibhekene nezinselelo ezivela ezilimini zesimanje, i-C iyaqhubeka nokuthuthuka futhi ijwayelane nezidingo eziguqukayo zemboni. Isingeniso solimi C sibalulekile ukuze uqonde lezi zici kanye nokuhambisana kwazo emkhakheni.

Konjiniyela, ukugcina nokuthuthukisa amakhono e-C kuhlala kuwutshalomali olubalulekile. Ikhono lika-C lokusebenzelana ngokuqondile ne-hardware, kuhlanganiswe nokusebenza kahle kwayo, kuyenza ilungele uhla olubanzi lwezinhlelo zokusebenza, kusukela kumasistimu ashumekiwe kuya kusofthiwe esebenza kahle kakhulu. Lokhu kusebenza kahle kungabongwa kusukela ngesikhathi sokuqala esethulweni solimi C, lapho kutholakala khona amakhono alo kanye nokusetshenziswa okungokoqobo.

Ikusasa lika-C libonakala liqinisekile, okungenani esikhathini esimaphakathi, ngenxa yesisekelo sayo esikhulu sekhodi esikhona, ukuvela kwayo okuqhubekayo kanye nendima yayo ebalulekile ekuthuthukisweni kwezinhlelo ezibucayi. Njengoba ubuchwepheshe buthuthuka, i-C izoqhubeka nokujwayela futhi ithole ama-niches amasha, igcine isikhundla sayo njengolunye lwezilimi zokuhlela ezinethonya kakhulu futhi ezihlala njalo emlandweni wekhompyutha.

 

Imibuzo Evame Ukubuzwa Ngesingeniso Solimi C

1. Yini eyenza u-C ahluke kwezinye izilimi zokuhlela?

C ihlukaniswa ngokusebenza kahle kwayo, ukuphatheka, kanye nokulawula okuphansi kwehadiwe. Ngokungafani nezilimi ezisezingeni eliphezulu, i-C ivumela ukuphathwa kwenkumbulo okuqondile futhi inikeze ukusebenza okuseduze nalokho kolimi lomshini, iyenze ilungele ukuthuthukisa amasistimu okusebenza, izishayeli zedivayisi, nezinhlelo zokusebenza ezidinga ukusebenza kahle okuphezulu.

2. Ingabe u-C uwulimi oluhle lwabaqalayo ezinhlelweni?

Nakuba u-C enejika lokufunda eliwumqansa, kungaba ulimi oluhle kakhulu lwabaqalayo abafuna ukuqonda izisekelo zokuhlela nokuthi amakhompyutha asebenza kanjani ezingeni eliphansi. Nokho, kudinga ukuqonda okujulile kwemiqondo efana nokuphathwa kwenkumbulo, okungaba inselele kwabanye abasaqalayo.

3. Injani i-C uma iqhathaniswa ne-C++?

I-C++ isandiso sika-C esengeza izici ze Izinhlelo eziqondiswe entweni, phakathi kwabanye. Nakuba u-C kuwulimi lwenqubo oluhlanzekile, i-C++ ihlanganisa ukuhlelwa kwenqubo kanye kuthambekele ezintweni. I-C ivamise ukuba lula futhi iqonde kakhudlwana, kuyilapho i-C++ inikela ngezinto ezifushanisayo ezengeziwe nezici ezisezingeni eliphezulu.

4. Yiziphi izinhlelo zokusebenza ezivame kakhulu ze-C namuhla?

I-C isetshenziswa kabanzi ekuthuthukisweni kwezinhlelo zokusebenza, amasistimu ashumekiwe, izishayeli zedivayisi, izinhlelo zokusebenza ezisebenza kahle kakhulu, imininingwane yolwazi, nasekuthuthukisweni kwezinye izilimi zokuhlela namathuluzi okuthuthukisa.

5. UC ukuphatha kanjani inkumbulo?

I-C inikeza ukulawula okwenziwa ngesandla phezu kokuphathwa kwememori. Abahleli banesibopho sokwaba nokukhulula inkumbulo besebenzisa imisebenzi efana ne-malloc() kanye ne-free(). Lokhu kunikeza ukuguquguquka okukhulu nokusebenza kahle, kodwa futhi kungaholela eziphazameni ezinjengokuvuza kwenkumbulo uma kungaphathwa kahle.

6. Yimaphi amathuluzi abalulekile ekuhlelweni ku-C?

Amathuluzi abalulekile ahlanganisa i-C compiler (efana ne-GCC), umhleli wombhalo noma i-IDE (njengekhodi ye-Visual Studio noma Ikhodi::Amabhulokhi), isilungisi sephutha (njenge-GDB), namathuluzi okuhlaziya afana ne-Valgrind ukuze kutholwe ukuvuza kwenkumbulo nezinye izinkinga.