| ZER DAKIDAN: Array datu-mota ezagutzen dut, eta kateak deritzen char datu-motako elementuen arrayak ezagutzen ditut ere. ZER IKASIKO DUDAN: Karaktere-kateak lantzeko funtzio batzuk ikasiko ditut. |
Jarraian kateak lantzeko funtzio batzuk deskribatzen dira. Ez dira funtzio estandarrak eta string.h, liburutegia behar dute.
| unsigned int strlen(const char *kate); |
strln() funtzioak funtzioak katearen karaktere kopurua itzultzen du, kate erakusleak seinalatzen duen katearen luzera (amaierako null ez da konputatzen).
Adibiderako ikusi Kate bat hartu: scanf(), gets() eta fgets() artikuluaren bi adibideak./* STRLEN_funtzioa.cbp */
// strlen() funtzioak zenbaki oso baten bitartez katearen luzera efektiboa
// adierazten du, zenbakia itzultzean null karakterea ez du konputatzen
#include <stdio.h>
#include <string.h> // gets() eta strlen() funtzioetarako
#include <conio.h> // getch() funtziorako
#define MAXIMOA 8 // katea mugatzeko konstantea,
// 7 karaktere + null mugatzailea
int main()
{
char sKatea[MAXIMOA];
int iKont;
printf("\n");
printf("\n Katearen neurri MAXIMOA = %d karaktere (%d karaktere + null)", MAXIMOA, MAXIMOA-1);
printf("\n");
do
{
printf("\n Gehienez %d karaktereko katea eman (adibidez, 01234): ", MAXIMOA-1);
gets(sKatea);
if (strlen(sKatea) >= MAXIMOA)
printf("\n %d karaktere onartzen dira gehienez!", MAXIMOA-1);
} while (strlen(sKatea) >= MAXIMOA);
printf("\n Sartutako katea |%s| izan da,", sKatea);
printf("\n %d karaktere eta bukaeran null marka \n", (int)strlen(sKatea));
printf("\n ASCII KODEA KARAKTEREA");
printf("\n ----------- ----------");
for (iKont=0; iKont <= strlen(sKatea); iKont++)
{
printf("\n sKatea[%d]=%3d sKatea[%d]=%c", iKont, (int)sKatea[iKont], iKont, sKatea[iKont]);
if (iKont == strlen(sKatea))
printf(" <-- null karakterea");
}
printf("\n\n Edozein tekla sakatu exekuzioa amaitzeko... ");
getch();
printf("\n");
return 0;
}
| char *strcpy(char *kate1, const char *kate2); |
| char *strncpy(char *kate1, const char *kate2, size_t zenbat); |
strcpy() funtzioa eta strncpy() funtzioa antzekoak dira, strncpy() funtzioaren hirugarren parametroan aldea dago, kopuru oso bat den parametro horri esker bermatzen da kate2 katetik gehienez zenbat karaktere kopiatuko direla.
strcpy() funtzioa kate2 katearen edukia kate1 katean kopiatzeko erabiltzen da. Bigarren parametroa, kate2, kate bati seinalatzen dion erakusle bat izan behar du, karaktere nuluarekin amaitzen dena. Funtzioak kate1 kateari seinalatzen dion erakusle bat itzultzen du.
Adibiderako Ariketa 48 | Kateen hasieraketak artikuluko ariketari aldaketa bat egingo diogu. Kate baten hasieraketa burutu ondoren, bere edukia beste bigarren kate batean gorde nahi da.
/* STRCPY_funtzioa.cbp */
// strcpy() funtzioak kate bat den bigarren parametroa beste kate bat den lehen
// parametroan kopiatzen du eta azken honi dagokion erakuslea itzultzen du
// Karaktere-kateak '\0' markaz bukatzen diren arrayak dira C lengoaian
// Kate baten hasieraketa katearen definizioan egin daiteke
// strlen() funtzioak katearen luzera efektiboa adierazten du
#include <stdio.h>
#include <string.h> // puts(), strlen() eta strcpy() funtzioetarako
#include <conio.h> // getch() funtziorako
#define MAXIMOA 7 // katea mugatzeko konstantea, 6 karaktere + null mugatzailea
int main()
{
char sKateDatua[MAXIMOA] = "ABCD"; // 4 letra + null + null + null
char sKateEmaitza[MAXIMOA]; // 6 karaktere + null gordetzeko katea
char *pErak; // karaktere bati erakuslea
int iKont;
printf("\n char *strcpy(char *sHelburu, const char *sDatu);");
printf("\n ================================================\n");
printf("\n Karaktere-kateen muga MAXIMOA=%d edo (%d+null)", MAXIMOA, MAXIMOA-1);
printf("\n char sKateDatua[%d]=\"ABCD\"; // hasieraketarekin", MAXIMOA);
printf("\n strlen(sKateDatua)=Luzera=%d sKateDatua=|%s| puts()=", (int)strlen(sKateDatua), sKateDatua);
puts(sKateDatua);
printf(" ------------------ -----------------");
printf("\n ASCII KODEA KARAKTEREA");
printf("\n ------------------ -----------------");
for (iKont=0; iKont < MAXIMOA; iKont++)
{
printf("\n sKateDatua[%d] = %2d sKateDatua[%d] = %c", iKont, (int)sKateDatua[iKont], iKont, sKateDatua[iKont]);
if (sKateDatua[iKont] == '\0')
printf(" <-- null marka");
}
printf("\n ------------------ -----------------");
// sKateEmaitza = sKateDatua; esleipen hau ezin daiteke egin
pErak = strcpy(sKateEmaitza, sKateDatua);
printf("\n\n pErak = %d sKateEmaitza = %d <-- helbideak berdinak dira", (int)pErak, (int)sKateEmaitza);
printf("\n");
printf("\n sKateEmaitza = sKateDatua; // esleipena ez da zilegia, horren ordez...");
printf("\n strcpy(sHelburu, sDatu); // ...lehena irteerakoa bigarrena sarrerakoa");
printf("\n strcpy(sKateEmaitza, sKateDatua); // egin ondoren");
printf("\n strlen(sKateEmaitza)=Luzera=%d sKateEmaitza=|%s| puts()=", (int)strlen(sKateEmaitza), sKateEmaitza);
puts(sKateEmaitza);
printf(" -------------------- -------------------");
printf("\n ASCII KODEA KARAKTEREA");
printf("\n -------------------- -------------------");
for (iKont=0; iKont < MAXIMOA; iKont++)
{
printf("\n sKateEmaitza[%d] =%3d sKateEmaitza[%d] =%2c", iKont, (int)sKateEmaitza[iKont], iKont, sKateEmaitza[iKont]);
if (iKont == strlen(sKateEmaitza))
printf(" <-- null marka");
if (iKont > strlen(sKateEmaitza))
printf(" edozein karaktere");
}
printf("\n -------------------- -------------------");
printf("\n\n");
printf("\n Kate beretik karaktereak ezabatu strcpy() bitartez");
printf("\n ==================================================\n");
char sKatea[]= "0123456789";
printf("\n char sKatea[]=\"0123456789\"; // lehen hasieraketa");
printf("\n strcpy(sKatea, \"0123456789\"); // edozein ezabaketa egin aurretik\n");
strcpy(sKatea, "0123456789");
printf("\n sKatea=|%s|", sKatea);
strcpy(sKatea, sKatea+1);
printf("\n strcpy(sKatea, sKatea+1); egin ondoren... sKatea=|%s|", sKatea);
strcpy(sKatea, "0123456789");
printf("\n sKatea=|%s|", sKatea);
strcpy(sKatea, sKatea+3);
printf("\n strcpy(sKatea, sKatea+3); egin ondoren... sKatea=|%s|", sKatea);
strcpy(sKatea, "0123456789");
printf("\n sKatea=|%s|", sKatea);
strcpy(sKatea+2, sKatea);
printf("\n strcpy(sKatea+2, sKatea); egin ondoren... sKatea=|%s|", sKatea);
strcpy(sKatea, "0123456789");
printf("\n sKatea=|%s|", sKatea);
strcpy(sKatea+1, sKatea+5);
printf("\n strcpy(sKatea+1, sKatea+5); egin ondoren... sKatea=|%s|", sKatea);
strcpy(sKatea, "0123456789");
printf("\n sKatea=|%s|", sKatea);
strcpy(sKatea+3, sKatea+8);
printf("\n strcpy(sKatea+3, sKatea+8); egin ondoren... sKatea=|%s|", sKatea);
printf("\n\n\n Edozein tekla sakatu exekuzioa amaitzeko... ");
getch();
printf("\n");
return 0;
}
strcpy() funtzioa eta strncpy() funtzioa antzekoak dira, strncpy() funtzioaren hirugarren parametroan aldea dago, kopuru oso bat den parametro horri esker bermatzen da kate2 katetik gehienez zenbat karaktere kopiatuko diren.
strncpy() funtzioak kate2 katearen lehen zenbat karaktereak kate1 katean kopiatzen ditu, baina ez du null karakterea gehitzen. Sarrerakoa den bigarren parametroa, kate2, kate bati seinalatzen dion erakusle bat izan behar du, karaktere nuluarekin amaitzen dena.
Funtzioak kate1 kateari seinalatzen dion erakusle bat itzultzen du ere.
Jarraian ematen den adibidean sKate_Datu katearen lehen 3 karaktereak sKate_Helburu_A katean kopiatuko dira, baina null karaktererik ez denez kopiatu sKate_Helburu_A katearen edukia ez da fidagarria izango. Bestalde, sKate_Datu katearen lehen 3 karaktereak sKate_Helburu_B katean kopiatuko dira ere, baina kasu honetan sKate_Helburu_B kateak null karakterez beterik dagoelako sKate_Helburu_B katearen edukia fidagarria izango da.
/* STRNCPY_funtzioa.cbp */
// strncpy() funtzioaren parametroak: lehen parametroa irteerako kate bat,
// bigarren parametroa sarrerako beste kate bat eta hirugarren parametroa
// sarrerako zenbaki oso bat. Bigarren parametroaren hainbat karaktere hartu
// eta lehen parametroan kopiatzen ditu.
// strncpy() funtzioak ez du '\0' marka gehitzen kopiaketa egitean.
#include <stdio.h>
#include <string.h> // puts(), strlen() eta strcpy() funtzioetarako
#include <conio.h> // getch() funtziorako
#define MAXIMOA 6 // katea mugatzeko konstantea, 5 karaktere + null mugatzailea
int main()
{
char sKate_Datu[MAXIMOA] = "ABCD"; // 4 letra + null + null
char sKate_Helburu_A[MAXIMOA] = "abcde"; // 5 letra + null
char sKate_Helburu_B[MAXIMOA] = ""; // 6 karaktere (denak null)
char *pErak; // karaktere bati erakuslea
int iKont;
printf("\n char *strncpy(char *sHelburu, const char *sDatu, size_t n);");
printf("\n ===========================================================\n");
printf("\n Karaktere-kateen muga MAXIMOA=%d edo (%d+null)\n", MAXIMOA, MAXIMOA-1);
printf("\n char sKate_Datu[%d]=\"ABCD\"; // hasieraketarekin", MAXIMOA);
printf("\n strlen(sKate_Datu)=%d sKate_Datu=|%s|", strlen(sKate_Datu), sKate_Datu);
printf("\n ------------------ -----------------");
printf("\n ASCII KODEA KARAKTEREA");
printf("\n ------------------ -----------------");
for (iKont=0; iKont < MAXIMOA; iKont++)
{
printf("\n sKate_Datu[%d] = %2d sKate_Datu[%d] = %c", iKont, (int)sKate_Datu[iKont], iKont, sKate_Datu[iKont]);
if (iKont >= strlen(sKate_Datu))
printf(" <-- null marka");
}
printf("\n ------------------ -----------------");
printf("\n");
printf("\n char sKate_Helburu_A[%d] = \"abcde\"; // hasieraketarekin", MAXIMOA);
printf("\n strlen(sKate_Helburu_A)=%d sKate_Helburu_A=|%s|", strlen(sKate_Helburu_A), sKate_Helburu_A);
printf("\n ----------------------- ----------------------");
printf("\n ASCII KODEA KARAKTEREA");
printf("\n ----------------------- ----------------------");
for (iKont=0; iKont < MAXIMOA; iKont++)
{
printf("\n sKate_Helburu_A[%d] =%3d sKate_Helburu_A[%d] =%2c", iKont, (int)sKate_Helburu_A[iKont], iKont, sKate_Helburu_A[iKont]);
}
printf("\n ----------------------- ----------------------");
printf("\n");
printf("\n sKate_Helburu_A katea \"abcde\" hasieraketarekin");
printf("\n ==============================================");
// sKate_Helburu_A = sKate_Datu; esleipen hau ezin daiteke egin
strncpy(sKate_Helburu_A, sKate_Datu, 3);
printf("\n strncpy(sHelburu, sDatu, iZenbat); // irteera, sarrera, sarrera");
printf("\n strncpy(sKate_Helburu_A, sKate_Datu, 3); // egin ondoren");
printf("\n strlen(sKate_Datu)=%d sKate_Datu=|%s|", strlen(sKate_Datu), sKate_Datu);
printf("\n strlen(sKate_Helburu_A)=%d sKate_Helburu_A=|%s| <-- hau txarto dago", strlen(sKate_Helburu_A), sKate_Helburu_A);
sKate_Helburu_A[3] = '\0'; // null karakterea eskuz jarri ondoren
printf("\n sKate_Helburu_A[3] = '\\0'; // null karakterea eskuz jarri ondoren");
printf("\n strlen(sKate_Datu)=%d sKate_Datu=|%s|", strlen(sKate_Datu), sKate_Datu);
printf("\n strlen(sKate_Helburu_A)=%d sKate_Helburu_A=|%s| <-- hau ondo dago", strlen(sKate_Helburu_A), sKate_Helburu_A);
printf("\n\n");
printf("\n char sKate_Helburu_B[%d] = \"\"; // hasieraketarekin", MAXIMOA);
printf("\n strlen(sKate_Helburu_B)=%d sKate_Helburu_B=|%s|", strlen(sKate_Helburu_A), sKate_Helburu_A);
printf("\n ----------------------- ----------------------");
printf("\n ASCII KODEA KARAKTEREA");
printf("\n ----------------------- ----------------------");
for (iKont=0; iKont < MAXIMOA; iKont++)
{
printf("\n sKate_Helburu_B[%d] =%3d sKate_Helburu_B[%d] =%2c", iKont, (int)sKate_Helburu_B[iKont], iKont, sKate_Helburu_B[iKont]);
}
printf("\n ----------------------- ----------------------");
printf("\n");
printf("\n sKate_Helburu_B katea hasieran kate hutsa");
printf("\n =========================================");
// sKate_Helburu_B = sKate_Datu; esleipen hau ezin daiteke egin
pErak = strncpy(sKate_Helburu_B, sKate_Datu, 3);
printf("\n strncpy(sHelburu, sDatu, iZenbat); // irteera, sarrera, sarrera");
printf("\n pErak = strncpy(sKate_Helburu_B, sKate_Datu, 3); // egin ondoren");
printf("\n strlen(sKate_Datu)=%d sKate_Datu=|%s|", strlen(sKate_Datu), sKate_Datu);
printf("\n strlen(sKate_Helburu_B)=%d sKate_Helburu_B=|%s| <-- hau ondo dago", strlen(sKate_Helburu_B), sKate_Helburu_B);
printf("\n pErak = %d sKate_Helburu_B = %d <-- helbideak berdinak dira", (int)pErak, (int)sKate_Helburu_B);
printf("\n");
getch();
return 0;
}
| int strcmp(const char *kate1, const char *kate2); |
|
int strncmp(const char *kate1, const char *kate2, size_t zenbat); |
strcmp() funtzioa eta strncmp() funtzioa antzekoak dira, strncmp() funtzioaren hirugarren parametroan aldea dago, kopuru oso bat den parametro horri esker konparaketa mugatzen da. Beraz, lehen zenbat karaktereekin erabakitzen da kate1 katea nolakoa den kate2 katearekiko.
strcmp() funtzioa kate2 katearen edukia kate1 katearen edukia konparatzeko erabiltzen da, alderaketa karakterez karaktere egiten da ASCII taularen arabera. Konparaketaren emaitza taula honetan jaso da, hots, strcmp() funtzioak itzultzen duena taula hau da:
| Itzulitako balioa | Deskribapena |
| zero baino txikiagoa | kate1 txikiago kate2 baino |
| zero | kate1 eta kate2 berdinak |
| zero baino handiagoa | kate1 handiago kate2 baino |
Jarraian erakusten den adibidean bi kate irakurtzen dira gets(sKate1) eta gets(sKate2) eginez. Gogoratu Kate bat hartu eta pantailaratu artikuluko bigarren ariketan azpimarratutakoa, programadoreari dagokiola kate baten luzera kontrolatzea bere erreserbatik kanpo joan ez dadin.
/* STRCMP_funtzioa.cbp */
// strcmp() funtzioak bi kate konparatzeko erabil daiteke
// lehen parametroa bigarren parametroa baino txikiagoa bada, emaitza negatiboa da
// lehen parametroa bigarren parametroa baino handiagoa bada, emaitza positiboa da
// lehen parametroa eta bigarren parametroa berdinak badira, emaitza zero da
#include <stdio.h>
#include <string.h> // gets(), strlen(), strcpy() eta strcmp() funtzioetarako
#include <conio.h> // getch() funtziorako
#define MAXIMOA 7 // katea mugatzeko konstantea,
// 6 karaktere + null mugatzailea
int main()
{
char sKate1[MAXIMOA]; // 6 karaktere + null gordetzeko katea
char sKate2[MAXIMOA]=""; // 6 karaktere + null gordetzeko katea
char sKate1Gorde[MAXIMOA];
int iEmaitza;
printf("\n\n ---------------------------------------------------------------------\n");
printf("\n sKate1Gorde-ren helbidea: %d", (int)sKate1Gorde);
printf("\n sKate2-ren helbidea: %d <--- bere muga gainditzean...", (int)sKate2);
printf("\n sKate1-ren helbidea: %d <--- posizio hauek hartuko ditu\n", (int)sKate1);
printf("\n Kontuz!!! sKate2 luzeegia bada, bere azken karaktereak");
printf("\n sKate1 aldagaiaren posizioetan kokatuko dira");
printf("\n Horregatik, sKate1Gorde aldagaian sKate1 edukiaren kopia egingo da");
printf("\n\n ---------------------------------------------------------------------\n");
printf("\n Karaktere kopuru maximoa %d izan arren, ondoko datuak eman...", MAXIMOA-1);
printf("\n\n");
do
{
printf(" Lehen katea eman (adibidez: 0123 edo 2222 edo 3210): ");
gets(sKate1);
if (strlen(sKate1) >= MAXIMOA)
printf(" Gehienez %d karaktereko katea behar da \n", MAXIMOA-1);
} while (strlen(sKate1) >= MAXIMOA);
strcpy(sKate1Gorde, sKate1);
printf(" sKate1=|%s| sKate1Gorde=|%s| \n", sKate1, sKate1Gorde);
printf("\n Bigarren katea eman (adibidez, luzeegia den hau: 0123456789): ");
do
{
gets(sKate2);
if (strlen(sKate2) >= MAXIMOA)
{
printf(" Gehienez %d karaktereko katea behar da ", MAXIMOA-1);
printf("\n Bigarren katea eman (adibidez, 2222): ");
}
} while (strlen(sKate2) >= MAXIMOA);
printf("\n Lehen katea sKate1=/%s/", sKate1);
printf("\n Bigarren katea sKate2=/%s/", sKate2);
strcpy(sKate1, sKate1Gorde);
printf("\n strcpy(sKate1, sKate1Gorde); egin ondoren...");
printf("\n Lehen katea sKate1=/%s/", sKate1);
printf("\n Bigarren katea sKate2=/%s/", sKate2);
iEmaitza = strcmp(sKate1, sKate2);
if (iEmaitza == 0)
printf("\n\n |%s| katea eta |%s| katea berdinak dira", sKate1, sKate2);
if (iEmaitza < 0)
printf("\n\n |%s| katea txikiagoa da |%s| katea baino", sKate1, sKate2);
if (iEmaitza > 0)
printf("\n\n |%s| katea handiagoa da |%s| katea baino", sKate1, sKate2);
printf("\n\n Edozein tekla sakatu exekuzioa amaitzeko... ");
getch();
printf("\n");
return 0;
}
Lehen iZENBAT karaktereak aintzakotzat hartuz sKate1 eta sKate2 alderatu:
/* STRNCMP_funtzioa.cbp */
// strncmp() funtzioak bi kateren lehen n karaktereak konparatzeko erabil daiteke
// Hirugarren parametroak adierzten duen n kopurura mugatuz...
// lehen parametroa bigarren parametroa baino txikiagoa bada, emaitza negatiboa da
// lehen parametroa bigarren parametroa baino handiagoa bada, emaitza positiboa da
// lehen parametroa eta bigarren parametroa berdinak badira, emaitza zero da
#include <stdio.h>
#include <string.h> // strncmp() funtzioetarako
#define iZENBAT 4 // frogak egiteko balio hau aldatu
int main()
{
char sKate1[] = "Kaixo mundua!"; // frogak egiteko kate hau aldatu
char sKate2[] = "Kaixo planeta!";
int iEmaitza;
// sKate1 eta sKate2 kateen lehen iZENBAT karaktereak alderatzen ditu
iEmaitza = strncmp(sKate1, sKate2, iZENBAT);
if (iEmaitza == 0)
{
printf("Bi kateen lehen %d karaktereak berdinak dira.\n", iZENBAT);
}
else if (iEmaitza < 0)
{
printf("sKate1 katearen lehen %d karaktereak txikiagoak dira sKate2 katearenak baino.\n", iZENBAT);
}
else
{
printf("sKate1 katearen lehen %d karaktereak handiagoak dira sKate2 katearenak baino.\n", iZENBAT);
}
return 0;
}
| char *strcat(char *kate1, const char *kate2); |
strcat() funtzioa kate1 katearen edukia eta kate2 katearen edukia elkartzeko erabiltzen da. Kateaketaren emaitza kate1 kateak jasotzen du eta funtzioak kate1 kateari seinalatzen dion erakusle bat itzultzen du.
/* STRCAT_funtzioa.cbp */
// strcat() funtzioak kate baten ostean beste kate bat jartzen du,
// kontuz helburuko kate1 aldagaiaren memoriako posizioak gainditu daitezkeelako
#include <stdio.h>
#include <string.h> // gets(), strlen() eta strcat() funtzioetarako
#include <conio.h> // getch() funtziorako
#define MAXIMOA 11 // katea mugatzeko konstantea,
// 10 karaktere + null mugatzailea
int main()
{
char sKate1[MAXIMOA]; // 10 karaktere + null gordetzeko katea
char sKate2[MAXIMOA] = "ABCD"; // 4 letra + 7 null
int iKont;
printf("\n");
printf("\n char sKate2[%d]=\"ABCD\"; // hasieraketarekin", MAXIMOA);
printf("\n Luzera=%d sKate2=|%s| puts()=", strlen(sKate2), sKate2);
puts(sKate2);
printf(" ASCII KODEA KARAKTEREA");
printf("\n ----------- ----------");
for (iKont=0; iKont <= strlen(sKate2); iKont++)
{
printf("\n sKate2[%d] = %2d sKate2[%d] = %c", iKont, (int)sKate2[iKont], iKont, sKate2[iKont]);
if (iKont == strlen(sKate2))
printf(" <-- null marka");
}
printf("\n\n");
do
{
printf(" sKate1 lehen katea eman (adibidez: 01234 edo 01234567): ");
gets(sKate1);
if (strlen(sKate1) >= MAXIMOA)
printf(" Gehienez %d karaktereko katea behar da \n", MAXIMOA-1);
} while (strlen(sKate1) >= MAXIMOA);
if (strlen(sKate1) + strlen(sKate2) < MAXIMOA)
{
strcat(sKate1, sKate2);
printf("\n strcat(sKate1, sKate2) egin ondoren");
printf("\n sKate1 = |%s|", sKate1);
printf("\n sKate2 = |%s|", sKate2);
}
else
printf("\n Ezin daiteke kateaketa egin, helburuko kateak toki nahikorik ez duelako");
printf("\n\n Edozein tekla sakatu exekuzioa amaitzeko... ");
getch();
printf("\n");
return 0;
}
| char *strchr(const char *kate, int karak); |
strchr() funtzioak karak karakterea bilatzen du kate katean. Aurkitzen badu, karak karakterearen lehen agerpenaren erakuslea itzultzen du. Ez badu karak aurkitzen null erakuslea itzultzen du.
/* STRCHR_funtzioa.cbp */
// strchr(katea, karak) funtzioak karak karakterea bilatzen du kate katean.
// Aurkitzen badu, karakterearen lehen agerpenaren erakuslea itzultzen du.
// Ez badu aurkitzen null erakuslea itzultzen du. Bilatutako karkaterearen
// posizioa zehazteko helbideen arteko kenketa egingo da.
#include <stdio.h>
#include <string.h> // strchr() funtziorako
#include <conio.h> // getch() eta getche() funtzioetarako
#define MAXIMOA 21 // katea mugatzeko konstantea,
// 20 karaktere + null mugatzailea
int main()
{
char sKatea[MAXIMOA] = "Kaixo mundua!"; // 13 letra + null mugatzailea
char cKarakterea;
char *erakuslea;
printf("\n");
printf("\n Luzera=%d sKatea=|%s|", (int)strlen(sKatea), sKatea);
printf("\n");
printf("\n Bilatu nahi den karaktere eman (adibidez: a edo u edo k): ");
cKarakterea = getche();
erakuslea = strchr(sKatea, cKarakterea);
printf("\n Bilaketaren emaitza: ||%s||", erakuslea);
if (erakuslea != NULL)
printf("\n Bilaketaren posizioa: |%d|", (int)(erakuslea - sKatea));
printf("\n\n Edozein tekla sakatu exekuzioa amaitzeko... ");
getch();
printf("\n");
return 0;
}
| char *strstr(const char *sKateNagusia, const char *sAzpikatea); |
strstr() funtzioak azpikate bat bilatzen du kate batean eta erakusle bat itzultzen du, lehen parametroa kate nagusia da eta bigarren parametroa bilatu nahi den azpikatea da (biak sarrerakoak). Bilaketak huts egiten badu azpikatea aurkitzen ez delako, funtzioak NULL itzultzen du. Bilaketa arrakastatsua bada, funtzioak azpikatearen helbidea itzultzen du; horregatik azpikatearen posizioa zein den kate nagusian jakin ahal izateko helbideen arteko kenketa burutu behar da. Hurrengo adibidea ikusi:
/* STRSTR_funtzioa.cbp */
// strstr() funtzioak azpikate bat bilatzen du kate batean, erakusle bat itzuliz.
// Bilaketa arrakastatsua bada, funtzioak azpikatearen helbidea itzultzen du.
// Azpikatea aurkitzen ez bada, funtzioak NULL itzultzen du.
// Bilaketa arrakastatsua bada, azpikatearen posizioa zein den kate nagusian
// lortzeko helbideen arteko kenketa burutu behar da.
#include <stdio.h>
#include <string.h> // strstr() funtziorako
int main()
{
const char *sNagusia = "Kaixo mundua!";
const char *sAzpikatea = "mundua"; // frogak egiteko kate hau aldatu
char *pErak;
int iKont;
pErak = strstr(sNagusia, sAzpikatea);
if (pErak != NULL)
{
printf(" Kate nagusia |%s| izanik...\n", sNagusia);
printf(" |%s| azpikatea posizio honetan aurkitzen da: %d\n", sAzpikatea, pErak - sNagusia);
printf("\n ----------------------- ------------------ ----------------");
printf("\n HELBIDEA ASCII KODEA KARAKTEREA");
printf("\n ----------------------- ------------------ ----------------");
for (iKont=0; iKont < strlen(sNagusia)+1; iKont++)
{
printf("\n &sNagusia[%2d] = %7d sNagusia[%2d] = %2d\tsNagusia[%2d] = %c", iKont, (int)&sNagusia[iKont], iKont, (int)sNagusia[iKont], iKont, sNagusia[iKont]);
if (iKont >= strlen(sNagusia))
printf(" <-- null marka");
}
printf("\n ----------------------- ------------------ ----------------\n");
printf("\n pErak - sNagusia = %d", pErak - sNagusia);
printf("\n %d - %d = %d", (int)pErak, (int)sNagusia, pErak - sNagusia);
}
else
{
printf("|%s| azpikatea ez da aurkitzen |%s| katean.\n", sAzpikatea, sNagusia);
}
printf("\n\n");
return 0;
}
| char *strupr(char *sKatea); |
| char *strlwr(char *sKatea); |
strupr() funtzioak kate bat larrietan jartzen du eta strlwr() funtzioak kate bat xeheetan jartzen du. Hurrengo adibidea ikusi:
/* STRUPRetaSTRLWR_funtzioak.cbp */
// strupr() funtzioak kate bat larrietan jartzen du.
// strlwr() funtzioak kate bat xeheetan jartzen du.
#include <stdio.h>
#include <string.h> // strupr() eta strlwr() funtzioetarako
int main()
{
char sKatea[ ] = "Kaixo MUNdua!";
printf("\n strupr() funtzioz ---> |%s|", strupr(sKatea));
printf("\n strlwr() funtzioz ---> |%s|", strlwr(sKatea));
printf("\n");
return 0;
}
| double atof(const char *ZenbakiErak); |
atof() funtzioak kate bat zenbaki erreal bihurtzen du, baldin eta katearen edukia zenbaki erreal baten itxura badu (bihurketa ezinezkoa bada 0.0 balioa itzultzen da). Hurrengo adibidea ikusi:
/* ATOF_funtzioa.cbp */
// double atof(const char *numPtr);
// Zenbaki bat adierazten duen kate bat eman eta zenbakia itzuliko du.
// Arrakasta badu, funtzioak bihurtutako zenbaki erreala itzultzen du,
// arrakastarik ez badu atof() funtzioak 0.0 balioa itzuliko du.
// Hasierako karaktere batzuk zifrak badira zati hori bihurtuko du.
#include <stdio.h>
#include <stdlib.h> // atof() funtziorako
int main()
{
char sZenbakienKatea[] = "123.45"; // Karaktere-katea
float fZenbakiErreal;
char sLetrenKatea[] = "xyz.uvwr"; // Karaktere-katea
float fEzinErreal;
char sKateNahastua[] = "95.5W67"; // Karaktere-katea
float fAhalDuena;
// atof() funtzioak karaktere-katea zenbaki dezimal bihurtzen du
fZenbakiErreal = atof(sZenbakienKatea);
printf("Karaktere-katea: %s\n", sZenbakienKatea);
printf("Zenbaki erreal bihurtua: %f\n", fZenbakiErreal);
printf("\n");
// datu horrekin atof() funtzioak ezingo du zenbakia lortu
fEzinErreal = atof(sLetrenKatea);
printf("Karaktere-katea: %s\n", sLetrenKatea);
printf("Zenbaki erreal bihurtua: %f\n", fEzinErreal);
printf("\n");
// datu horrekin atof() funtzioak zenbaki zati lortuko du
fAhalDuena = atof(sKateNahastua);
printf("Karaktere-katea: %s\n", sKateNahastua);
printf("Zenbaki erreal bihurtua: %f\n", fAhalDuena);
printf("\n");
return 0;
}
iruzkinik ez:
Argitaratu iruzkina