perlclib - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

perlclib - സ്റ്റാൻഡേർഡ് C ലൈബ്രറി ഫംഗ്‌ഷനുകൾക്കുള്ള ആന്തരിക റീപ്ലേസ്‌മെന്റുകൾ

വിവരണം

പേൾ പോർട്ടർമാർ ശ്രദ്ധിക്കേണ്ട ഒരു കാര്യം മുത്ത് സി അത്രയധികം ഉപയോഗിക്കാൻ പ്രവണത കാണിക്കുന്നില്ല
ആന്തരികമായി സാധാരണ ലൈബ്രറി; നിങ്ങൾ വളരെ കുറച്ച് ഉപയോഗം കാണും, ഉദാഹരണത്തിന് ctype.h
അവിടെ പ്രവർത്തിക്കുന്നു. കാരണം, സ്റ്റാൻഡേർഡ് ലൈബ്രറി പുനഃസ്ഥാപിക്കാനോ അമൂർത്തമാക്കാനോ പേൾ പ്രവണത കാണിക്കുന്നു
ഫംഗ്‌ഷനുകൾ, അതിനാൽ അവ എങ്ങനെ പ്രവർത്തിക്കുമെന്ന് ഞങ്ങൾക്ക് കൃത്യമായി അറിയാം.

സി ലൈബ്രറിയുമായി പരിചയമുള്ളവരും ചെയ്യാൻ ആഗ്രഹിക്കുന്നവരുമായ ആളുകൾക്കുള്ള റഫറൻസ് കാർഡാണിത്
കാര്യങ്ങൾ പേർൾ വഴി; കൂടുതൽ ഉപയോഗിക്കുന്നതിന് പകരം ഏതൊക്കെ ഫംഗ്‌ഷനുകളാണ് ഉപയോഗിക്കേണ്ടതെന്ന് അവരോട് പറയാൻ
സാധാരണ സി പ്രവർത്തനങ്ങൾ.

കൺവെൻഷനുകൾ
ഇനിപ്പറയുന്ന പട്ടികകളിൽ:

"ടി"
ഒരു തരം ആണ്.

"p"
ഒരു സൂചനയാണ്.

"n"
ഒരു സംഖ്യയാണ്.

"s"
ഒരു ചരടാണ്.

"sv", "av", "hv" മുതലായവ അവയുടെ അതാത് തരത്തിലുള്ള വേരിയബിളുകളെ പ്രതിനിധീകരിക്കുന്നു.

ഫയല് പ്രവർത്തനങ്ങൾ
പകരം stdio.h ഫംഗ്‌ഷനുകൾ, നിങ്ങൾ പേൾ അബ്‌സ്‌ട്രാക്ഷൻ ലെയർ ഉപയോഗിക്കണം. ഇതിനുപകരമായി
"FILE*" തരങ്ങൾ, നിങ്ങൾ "PerlIO*" തരങ്ങൾ കൈകാര്യം ചെയ്യേണ്ടതുണ്ട്. പുതിയതിനൊപ്പം അത് മറക്കരുത്
PerlIO ലേയേർഡ് I/O അബ്‌സ്‌ട്രാക്ഷൻ "FILE*" തരങ്ങൾ പോലും ലഭ്യമായേക്കില്ല. ഇതും കാണുക
ഇനിപ്പറയുന്ന ഫംഗ്‌ഷനുകളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് "perlapio" ഡോക്യുമെന്റേഷൻ:

പകരം: ഉപയോഗിക്കുക:

stdin PerlIO_stdin()
stdout PerlIO_stdout()
stderr PerlIO_stderr()

fopen(fn, മോഡ്) PerlIO_open(fn, മോഡ്)
ഫ്രീ ഓപ്പൺ (എഫ്എൻ, മോഡ്, സ്ട്രീം) PerlIO_reopen (fn, മോഡ്, പെർലിയോ) (ഡെപ്-
തിരിച്ചുപറഞ്ഞു)
ഫ്ലഷ്(സ്ട്രീം) PerlIO_flush(perlio)
fclose(stream) PerlIO_close(perlio)

ഫയല് ഇൻപുട്ട് ഒപ്പം ഔട്ട്പുട്ട്
പകരം: ഉപയോഗിക്കുക:

fprintf(stream, fmt, ...) PerlIO_printf(perlio, fmt, ...)

[f]getc(സ്ട്രീം) PerlIO_getc(perlio)
[f]putc(stream, n) PerlIO_putc(perlio, n)
ungetc(n, stream) PerlIO_ungetc(perlio, n)

"fread", "fwrite" എന്നിവയുടെ PerlIO തുല്യതകൾ അവയിൽ നിന്ന് അല്പം വ്യത്യസ്തമാണ് എന്നത് ശ്രദ്ധിക്കുക.
സി ലൈബ്രറി എതിരാളികൾ:

fread(p, size, n, stream) PerlIO_read(perlio, buf, numbytes)
fwrite(p, size, n, stream) PerlIO_write(perlio, buf, numbytes)

fputs(s, stream) PerlIO_puts(perlio, s)

"fgets" എന്നതിന് തുല്യമായ ഒന്നുമില്ല; പകരം "sv_gets" ഉപയോഗിക്കണം:

fgets(s, n, stream) sv_gets(sv, perlio, append)

ഫയല് പൊസിഷനിംഗ്
പകരം: ഉപയോഗിക്കുക:

feof(stream) PerlIO_eof(perlio)
fseek(സ്ട്രീം, n, എവിടെ നിന്ന്) PerlIO_seek(perlio, n, എവിടെ നിന്ന്)
റിവൈൻഡ്(സ്ട്രീം) PerlIO_rewind(perlio)

fgetpos(stream, p) PerlIO_getpos(perlio, sv)
fsetpos(stream, p) PerlIO_setpos(perlio, sv)

ഫെറർ(സ്ട്രീം) PerlIO_error(perlio)
clearerr(stream) PerlIO_clearerr(perlio)

മെമ്മറി മാനേജ്മെന്റ് ഒപ്പം സ്ട്രിംഗ് കൈകാര്യം
പകരം: ഉപയോഗിക്കുക:

t* p = malloc(n) Newx(p, n, t)
t* p = calloc(n, s) Newxz(p, n, t)
p = realloc(p, n) പുതുക്കുക(p, n, t)
memcpy(dst, src, n) പകർപ്പ് (src, dst, n, t)
memmove(dst, src, n) നീക്കുക(src, dst, n, t)
memcpy(dst, src, sizeof(t)) StructCopy(src, dst, t)
മെംസെറ്റ്(dst, 0, n * sizeof(t)) പൂജ്യം(dst, n, t)
memzero(dst, 0) പൂജ്യം(dst, n, char)
free(p) സുരക്ഷിതം(p)

strdup(p) savepv(p)
strndup(p, n) savepvn(p, n) (ഹേയ്, strndup ഇല്ല
നിലവിലുണ്ട്!)

strstr (വലിയ, ചെറിയ) instr (വലിയ, ചെറിയ)
strcmp(s1, s2) strLE(s1, s2) / strEQ(s1, s2)
/ strGT(s1,s2)
strncmp(s1, s2, n) strnNE(s1, s2, n) / strnEQ(s1, s2, n)

memcmp(p1, p2, n) memNE(p1, p2, n)
!memcmp(p1, p2, n) memEQ(p1, p2, n)

"memcpy" എന്നതിൽ ഉപയോഗിക്കുന്നതിനേക്കാൾ "പകർത്തുക", "നീക്കുക" എന്നീ ആർഗ്യുമെന്റുകളുടെ വ്യത്യസ്ത ക്രമം ശ്രദ്ധിക്കുക.
"മെമ്മൂവ്".

എന്നിരുന്നാലും, മിക്കപ്പോഴും, അസംസ്‌കൃതമായവയ്‌ക്ക് പകരം SV-കൾ ആന്തരികമായി കൈകാര്യം ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കും
"char *" സ്ട്രിംഗുകൾ:

strlen(s) sv_len(sv)
strcpy(dt, src) sv_setpv(sv, s)
strncpy(dt, src, n) sv_setpvn(sv, s, n)
strcat(dt, src) sv_catpv(sv, s)
strncat(dt, src) sv_catpvn(sv, s)
sprintf(s, fmt, ...) sv_setpvf(sv, fmt, ...)

"sv_catpvf", "sv_catpvfn" എന്നിവയുടെ അസ്തിത്വവും ശ്രദ്ധിക്കുക.
ഫോർമാറ്റിംഗ്.

ചിലപ്പോൾ അനുവദിച്ച കൂമ്പാരം പൂജ്യമാക്കുന്നതിനുപകരം ഉപയോഗിച്ച് Newxz() നിങ്ങൾ പരിഗണിക്കണം
ഡാറ്റ "വിഷം". നിയമവിരുദ്ധമായിരിക്കേണ്ട ഒരു ബിറ്റ് പാറ്റേൺ അതിൽ എഴുതുക എന്നാണ് ഇതിനർത്ഥം
പോയിന്ററുകൾ (ഒപ്പം ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ), കൂടാതെ പൂർണ്ണസംഖ്യകൾ പോലെ ആശ്ചര്യപ്പെടുത്തുന്നു,
അതിനാൽ മുൻകരുതലില്ലാതെ ഡാറ്റ ഉപയോഗിക്കാൻ ശ്രമിക്കുന്ന ഏതൊരു കോഡും പെട്ടെന്ന് തകരും
പിന്നീട് അധികം. ഉപയോഗിച്ച് വിഷബാധ നടത്താം വിഷം() സമാനമായ വാദങ്ങളുള്ള മാക്രോകൾ
ലേക്ക് പൂജ്യം():

PoisonWith(dst, n, t, b) ബൈറ്റ് ഉപയോഗിച്ച് സ്‌ക്രൈബിൾ മെമ്മറി
PoisonNew(dst, n, t) PoisonWith(dst, n, t, 0xAB) ന് തുല്യമാണ്
PoisonFree(dst, n, t) PoisonWith(dst, n, t, 0xEF) ന് തുല്യമാണ്
വിഷം (dst, n, t) PoisonFree (dst, n, t) ന് തുല്യമാണ്

കഥാപാത്രം ക്ലാസ് ടെസ്റ്റുകൾ
പേൾ നടപ്പിലാക്കുന്ന നിരവധി തരം ക്യാരക്ടർ ക്ലാസ് ടെസ്റ്റുകൾ ഉണ്ട്. മാത്രം
പ്രവർത്തിക്കുന്ന സി ലൈബ്രറി പ്രവർത്തനങ്ങളുമായി നേരിട്ട് പൊരുത്തപ്പെടുന്നവയാണ് ഇവിടെ വിവരിച്ചിരിക്കുന്നത്
8-ബിറ്റ് പ്രതീകങ്ങൾ, എന്നാൽ വൈഡ് പ്രതീകങ്ങളിൽ പ്രവർത്തിക്കുന്ന തത്തുല്യങ്ങൾ ഉണ്ട്, കൂടാതെ UTF-8
എൻകോഡ് ചെയ്ത സ്ട്രിംഗുകൾ. പെർലാപിയിലെ "പ്രതീക വർഗ്ഗീകരണത്തിൽ" എല്ലാം കൂടുതൽ പൂർണ്ണമായി വിവരിച്ചിരിക്കുന്നു
പെർലാപിയിൽ "കഥാപാത്രം മാറുന്നത്".

ചുവടെയുള്ള പട്ടികയിൽ ലിസ്‌റ്റ് ചെയ്‌തിരിക്കുന്ന സി ലൈബ്രറി ദിനചര്യകൾ നിലവിലുള്ളതിനെ അടിസ്ഥാനമാക്കിയുള്ള മൂല്യങ്ങൾ നൽകുന്നു
പ്രദേശം. ആ പ്രവർത്തനത്തിനായി അവസാന നിരയിലെ എൻട്രികൾ ഉപയോഗിക്കുക. മറ്റ് രണ്ട്
നിരകൾ എല്ലായ്പ്പോഴും ഒരു POSIX (അല്ലെങ്കിൽ C) ലൊക്കേൽ അനുമാനിക്കുന്നു. ASCII കോളത്തിലെ എൻട്രികൾ മാത്രമാണ്
ASCII ഇൻപുട്ടുകൾക്ക് അർത്ഥപൂർണമാണ്, മറ്റെന്തിനും FALSE നൽകുന്നു. നിങ്ങൾ ഉള്ളപ്പോൾ മാത്രം ഇവ ഉപയോഗിക്കുക
അറിയുക അതാണ് നിങ്ങൾ ആഗ്രഹിക്കുന്നത്. ലാറ്റിൻ1 കോളത്തിലെ എൻട്രികൾ ASCII അല്ലാത്തത് എന്ന് അനുമാനിക്കുന്നു
8-ബിറ്റ് പ്രതീകങ്ങൾ യൂണികോഡ് നിർവചിക്കുന്നത് പോലെയാണ്, അവ ISO-8859-1 ന് സമാനമാണ്, പലപ്പോഴും ലാറ്റിൻ എന്ന് വിളിക്കപ്പെടുന്നു
1.

പകരം: ASCII-യ്‌ക്ക് ഉപയോഗിക്കുക: Latin1-ന് ഉപയോഗിക്കുക: ലൊക്കേലിനായി ഉപയോഗിക്കുക:

isalnum(c) isALPHANUMERIC(c) isALPHANUMERIC_L1(c) isALPHANUMERIC_LC(c)
isalpha(c) isALPHA(c) isALPHA_L1(c) isALPHA_LC(u )
isascii(c) isASCII(c) isASCII_LC(c)
isblank(c) isBLANK(c) isBLANK_L1(c) isBLANK_LC(c)
iscntrl(c) isCNTRL(c) isCNTRL_L1(c) isCNTRL_LC(c)
isdigit(c) isDIGIT(c) isDIGIT_L1(c) isDIGIT_LC(c)
isgraph(c) isGRAPH(c) isGRAPH_L1(c) isGRAPH_LC(c)
islower(c) isLOWER(c) isLOWER_L1(c) isLOWER_LC(c)
isprint(c) isPRINT(c) isPRINT_L1(c) isPRINT_LC(c)
ispunct(c) isPUNCT(c) isPUNCT_L1(c) isPUNCT_LC(c)
isspace(c) isSPACE(c) isSPACE_L1(c) isSPACE_LC(c)
isupper(c) isUPPER(c) isUPPER_L1(c) isUPPER_LC(c)
isxdigit(c) isXDIGIT(c) isXDIGIT_L1(c) isXDIGIT_LC(c)

tolower(c) toLOWER(c) toLOWER_L1(c) toLOWER_LC(c)
toupper(c) toUPPER(c) toUPPER_LC(c)

നിങ്ങൾ ASCII പ്രതീകങ്ങളിൽ മാത്രമാണ് പ്രവർത്തിക്കുന്നതെന്ന് ഊന്നിപ്പറയുന്നതിന്, നിങ്ങൾക്ക് ഓരോന്നിനും "_A" ചേർക്കാവുന്നതാണ്
ASCII കോളത്തിലെ മാക്രോകളിൽ: "isALPHA_A", "isDIGIT_A", തുടങ്ങിയവ.

(ലത്തീൻ1 കോളത്തിൽ "isascii" എന്നതിന് ഒരു എൻട്രിയും ഇല്ലെങ്കിലും
"isASCII_L1", അത് "isASCII" ന് സമാനമാണ്; പിന്നീടുള്ള പേര് കൂടുതൽ വ്യക്തമാണ്. അവിടെ ഇല്ല
"ടൂപ്പർ" എന്നതിനായുള്ള ലാറ്റിൻ 1 കോളത്തിൽ എൻട്രി ചെയ്യുക, കാരണം ഫലം ലാറ്റിൻ അല്ലാത്തതാകാം. നിങ്ങൾക്കുണ്ട്
"toUPPER_uni" ഉപയോഗിക്കുന്നതിന്, പെർലാപിയിലെ "കഥാപാത്രം മാറുന്നതിൽ" വിവരിച്ചിരിക്കുന്നതുപോലെ.)

stdlib.h ഫംഗ്ഷനുകളും
പകരം: ഉപയോഗിക്കുക:

atof(കൾ) Atof(കൾ)
atoi(കൾ) grok_atoUV(s, &uv, &e)
atol(s) grok_atoUV(s, &uv, &e)
strtod(s, &p) ഒന്നുമില്ല. അത് ഉപയോഗിക്കരുത്.
strtol(s, &p, n) grok_atoUV(s, &uv, &e)
strtoul(s, &p, n) grok_atoUV(s, &uv, &e)

കാസ്റ്റുചെയ്യുന്നതിന് മുമ്പ് "uv"-യിൽ റേഞ്ച് പരിശോധനകൾ നടത്തുക എന്നതാണ് സാധാരണ ഉപയോഗം:

int i; യുവി യുവി; char* end_ptr;
എങ്കിൽ (grok_atoUV(ഇൻപുട്ട്, &uv, &end_ptr)
&& uv <= INT_MAX)
i = (int)uv;
... /* end_ptr മുതൽ പാഴ്‌സിംഗ് തുടരുക */
} else {
... /* പാഴ്‌സ് പിശക്: 0 .. MAX_IV */ ശ്രേണിയിലെ ദശാംശ പൂർണ്ണസംഖ്യയല്ല
}

ഇതിലെ "grok_bin", "grok_hex", "grok_oct" എന്നീ ഫംഗ്‌ഷനുകളും ശ്രദ്ധിക്കുക. numeric.c വേണ്ടി
അതാത് ബേസുകളിലെ സംഖ്യകളെ പ്രതിനിധീകരിക്കുന്ന സ്ട്രിംഗുകളെ "NV"കളാക്കി മാറ്റുന്നു. അതല്ല
grok_atoUV() നെഗറ്റീവ് ഇൻപുട്ടുകളോ ലീഡിംഗ് വൈറ്റ്‌സ്‌പെയ്‌സോ കൈകാര്യം ചെയ്യുന്നില്ല (ഉദ്ദേശ്യപൂർവ്വം
കണിശമായ).

അതല്ല strtol() ഒപ്പം strtoul() വേഷംമാറി വരാം സ്ട്രോൾ(), സ്ട്രോൾ(), അറ്റോൾ(), Atoul().
അവയും ഒഴിവാക്കുക.

സിദ്ധാന്തത്തിൽ "Strtol" ഉം "Strtoul" ഉം നിർവചിച്ചേക്കില്ല, മെഷീൻ perl നിർമ്മിച്ചിരിക്കുന്നത്
യഥാർത്ഥത്തിൽ strtol ഉം strtoul ഉം ഇല്ല. എന്നാൽ ആ 2 ഫംഗ്‌ഷനുകളും 1989-ന്റെ ഭാഗമാണ്
ANSI C സ്പെക് നിങ്ങൾ ഇപ്പോൾ എല്ലായിടത്തും അവരെ കണ്ടെത്തുമെന്ന് ഞങ്ങൾ സംശയിക്കുന്നു.

int rand() double Drand01()
srand(n) {seedDrand01((Rand_seed_t)n);
PL_srand_called = TRUE; }

exit(n) my_exit(n)
സിസ്റ്റം(കൾ) ചെയ്യരുത്. pp_system നോക്കുക അല്ലെങ്കിൽ my_popen ഉപയോഗിക്കുക.

getenv(കൾ) PerlEnv_getenv(കൾ)
setenv(s, val) my_setenv(s, val)

കലര്പ്പായ ഫംഗ്ഷനുകളും
നിങ്ങൾ പോലും പാടില്ല ആഗ്രഹിക്കുന്നു ഉപയോഗിക്കാൻ setjmp.h ഫംഗ്‌ഷനുകൾ, എന്നാൽ നിങ്ങൾ ചെയ്യുമെന്ന് നിങ്ങൾ കരുതുന്നുവെങ്കിൽ, ഉപയോഗിക്കുക
"JMPENV" സ്റ്റാക്ക് ഇൻ സ്കോപ്പ്.എച്ച് പകരം.

"സിഗ്നൽ"/"സിഗക്ഷൻ" എന്നതിന്, "rsignal(signo, handler)" ഉപയോഗിക്കുക.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് perlclib ഓൺലൈനായി ഉപയോഗിക്കുക