Macros stdlib: EXIT_FAILURE, EXIT_SUCCESS, MB_CUR_MAX, RAND_MAX

Macros stdlib.h

Macros:  EXIT_FAILURE & EXIT_SUCCESS

Expressions senceres que poden ser usades com l'argument per a la funció exit per retornar l'estat de terminació sense o amb èxit, respectivament, a l'entorn local.

----DJGPP-------------

#define EXIT_FAILURE 1
#define EXIT_SUCCESS 0

----Borland-----------

#define EXIT_SUCCESS 0
#define EXIT_FAILURE 1

----Dev-C++-------------

#define EXIT_SUCCESS 0
#define EXIT_FAILURE -1

Més informació -->Control de procesos

Macro:  MB_CUR_MAX

Una expressió sencera positiva el valor és el nombre màxim de bytes en un caràcter multibyte per al conjunt de caràcters estesos especificat per la localització actual (categoria LC_CTYPE), i el valor no és mai més gran que MB_LEN_MAX.

----DJGPP-------------

#define MB_CUR_MAX 1

----Borland-----------

#define MB_CUR_MAX 1

----Dev-C++-------------

SENSE DEFINIR

Més informació -->  Manipulació memòries multibytes

Macro:  RAND_MAX

Un Expressió constant d'interval, el valor del qual és el valor màxim retorat per la funció rand. El valor de la macro RAND_MAX serà de al menys 32767.

----DJGPP-------------

#define RAND_MAX 2147483647

----Borland-----------

#define RAND_MAX 0x7FFFU

----Dev-C++-------------

#define RAND_MAX 0x7FFF

Més informació -->  Generar numeros aleatoris

Més informació -->  llibreria <stdlib.h>

Estructures stdlib: div_t, ldiv_t, size_t, wchar_t

Estructures de la llibreria stdlib

Estructura div_t:     typedef<tipo>div_t; 

Un tipus d'estructura que és el tipus de la valor retornat per la funció div.

----DJGPP-------------

typedef struct {
    int quot;
    int rem;
} div_t;

 

----Borland-----------

typedef struct {
   int quot;
   int rem;
} div_t;

 

----Dev-C++-------------

typedef struct { int quot, rem; } div_t

Més informació -->funcio div

Estructura ldiv_t:     typedef<tipo>ldiv_t; 

Un tipus d'estructura que és el tipus de la valor retornat per la funció ldiv.

----DJGPP-------------

typedef struct {
   long quot;
   long rem;
} ldiv_t;

----Borland-----------

typedef struct {
   long quot;
   long rem;
} ldiv_t;

 

----Dev-C++-------------

typedef struct { long quot, rem; } ldiv_t;

Més informació -->funcio ldiv

Estructura size_t:     typedef<tipo>size_t; 

Aquest és el tipus integral no signat i és el resultat de la paraula clau sizeof

----DJGPP-------------

typedef long unsigned int size_t;

----Borland-----------

typedef unsigned size_t;

----Dev-C++-------------

typedef long unsigned int size_t;

Estructura wchar_t:     typedef<tipo>wchar_t;

Aquesta estructura guarda caràcters multibytes

Un tipus sencer el interval de valors pot representar codis únics per a totsels membres del conjunt més gran de caràcters estesos especificat d'entreles localitats suportades; el caràcter nul té el número de codi, zero, i cadamembre del conjunt bàsic de caràcters el número de codi igual al seu valor quanusat com el caràcter únic en una constant de caràcters sencers.

----DJGPP-------------

#define __DJ_wchar_t typedef unsigned short wchar_t;

----Borland-----------

typedef unsigned short wchar_t;

 

----Dev-C++-------------

#define __WCHAR_TYPE__ int
#endif
#ifndef __cplusplus
typedef __WCHAR_TYPE__ wchar_t;
#endif

Més informació -->  Manipulació memòries multibytes
Més informació -->  Caràcters multibytes

Més informació -->  llibreria <stdlib.h>

Funcions stdlib [9/9]: mblen, mbstowcs, mbtowc, wctomb

Manipulació memòries multibytes:

Les següentes funcions treballen amb Caràcters multibytes.

Funció mblen:     int mblen(const char *str,size_t n);

Retorna la longitud d’un caràcter multi-byte apuntat, per l’argument str .

str - Aquest és el punter al primer byte d'un caràcter multibyte.

n - Aquest és el nombre màxim de bytes que cal comprovar per a la longitud de caràcters.

La funció mblen () retorna el nombre d'octals passats de la seqüència de múltiples bytes a partir de str, si es reconeix com un caràcter ample no nul. Retorna 0, si es reconeix un caràcter nul ample  torna -1, si s'ha trobat una seqüència de bytes múltiples no vàlida o si no es pot analitzar un caràcter multi-byte complet.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main () {

   int len;

   char *pmbnull  = NULL;

   char *pmb = (char *)malloc( MB_CUR_MAX );

   wchar_t *pwc = L"Hi";

   wchar_t *pwcs = (wchar_t *)malloc( sizeof( wchar_t ));

   printf("Conversió a cadena multibyte\n");

   len = wcstombs( pmb, pwc, MB_CUR_MAX);

   printf("Caracters convertits %d\n", len);

   printf("Valor hexadecimal del primer caràcter multibyte: %#.4x\n", pmb);

   

   len = mblen( pmb, MB_CUR_MAX );

   printf( "Longitud en bytes de caràcter multibyte %x: %u\n", pmb, len );

   

   pmb = NULL;

   

   len = mblen( pmb, MB_CUR_MAX );

   printf( "Longitud en bytes de caràcter multibyte %x: %u\n", pmb, len );

   

   return(0);

}

Funció mbstowcs:      size_t mbstowcs(wchar_t *pwcs, const char *str, size_t n);

Converteix la cadena de caràcters de múltiples bytes a la qual es fa referència, per l’argument str a la matriu a la qual s’apunten pwcs .

pwcs : aquest és el punter a una matriu d'elements wchar_t que és prou llarg per emmagatzemar una cadena ampla de caràcters de màxim. 

 

str : Aquesta és la cadena de caràcters C de diversos bytes que s’ha d’interpretar. 

 

n - Aquest és el nombre màxim de caràcters wchar_t a interpretar.

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

int main () {

   int len;

   char *pmbnull  = NULL;

   char *pmb = (char *)malloc( MB_CUR_MAX );

   wchar_t *pwc = L"Hi";

   wchar_t *pwcs = (wchar_t *)malloc( sizeof( wchar_t ));

   printf("Conversió a cadena multibyte\n");

   len = wcstombs( pmb, pwc, MB_CUR_MAX);

   printf("Caracters convertits %d\n", len);

   printf("Valor hexadecimal del primer caràcter multibyte: %#.4x\n", pmb);

   

   printf("Tornant a la cadena de caràcters amples\n");

   len = mbstowcs( pwcs, pmb, MB_CUR_MAX);

   printf("Caracters convertits %d\n", len);

   printf("Valor hexadecimal del primer caràcter ampli %#.4x\n\n", pwcs);

   

   return(0);

}

Funció mbtowc:      int mbtowc(wchar_t *pwc, const char *str, size_t n);

Converteix una seqüència multibyte en un caràcter ampli.

pwc - Aquest és el punter a un objecte del tipus wchar_t.

str - Aquest és el punter al primer byte d'un caràcter de diversos bytes.

n - Aquest és el nombre màxim de bytes que cal comprovar per a la longitud de caràcters.

Si str no és NULL, la funció mbtowc () retorna el nombre de bytes consumits a partir de str, o 0 si s apunta a un byte nul, o -1 al fracàs.

Si str és NULL, la funció mbtowc () retorna nul si la codificació té un estat de desplaçament no trivial o zero si la codificació està sense estat.

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

int main () {

   char *str = "Aixos es un punter";

   wchar_t mb[100];

   int len;

   

   len = mblen(NULL, MB_CUR_MAX);       

   mbtowc(mb, str, len*strlen(str) );

   wprintf(L"%ls \n", mb );   

   

   return(0);

}

Funció wctomb:      int wctomb(char *str, wchar_t wchar);

Converteix l'ample wchar de caràcters a la seva representació multibyte i el guarda al començament de la matriu de caràcters apuntada per str .

str - Aquest és el punter a una matriu prou gran com per contenir un caràcter multibyte,
wchar : aquest és el caràcter ampli del tipus wchar_t.

Si str no és NULL, la funció wctomb () retorna el nombre d'octets que s'han escrit a la matriu de bytes a str. Si wchar no es pot representar com una seqüència multibyte, es retorna -1.

Si str és NULL, la funció wctomb () retorna nul si la codificació té un estat de desplaçament no trivial, o zero si la codificació està sense estat.

#include <stdio.h>

#include <stdlib.h>

int main () {

   int i;

   wchar_t wc = L'a';

   char *pmbnull = NULL;

   char *pmb = (char *)malloc(sizeof( char ));

   printf("Conversio de caracter ampli:\n");

   i = wctomb( pmb, wc );

   printf("caracters convertits: %u\n", i);

   printf(": %.1s\n", pmb);

   printf("Intenteu convertir la destinacio quan es NULL:\n");

   i = wctomb( pmbnull, wc );

   printf("Caracters convertits: %u\n", i);

   /* això no imprimirà cap valor */

   printf("Multibyte caracter: %.1s\n", pmbnull);

   

   return(0);

}

Més informació ->  Memòries: Caràcters multibytes

Més informació ->  Estructures stdlib
Més informació ->  Macros stdlib.h


Més informació ->  llibreria <stdlib.h>

Caràcters multibytes

{L'H', L'o', L'l', L'a', L'!', 0}

caràcters multibytes

En el codi ordinari ASCII, una seqüència de caràcters és una seqüència d'octals i cada personatge és un byte. Això és molt senzill, però permet només 256 caràcters diferents.

En un codi de caràcters multibyte , una seqüència de caràcters és una seqüència d'octal, però cada caràcter pot ocupar un o més bytes consecutius de la seqüència.

Hi ha moltes maneres diferents de dissenyar un codi de caràcters multibyte; diferents sistemes utilitzen codis diferents. Especificar un codi determinat significa designar les seqüències de bytes bàsiques (aquelles que representen un sol caràcter) i quins caràcters es diferencien. Un codi que un ordinador pot utilitzar realment ha de tenir un nombre finit d’aquestes seqüències bàsiques, i normalment cap d’elles té més de uns quants caràcters.

No és necessari que totes aquestes seqüències tinguin la mateixa longitud. De fet, molts d’ells tenen una durada de només un byte. Com que els caràcters bàsics ASCII de l'interval des 0 de 0177són tan importants que es distingeixen per si mateixos en tots els codis de caràcters multibyte. És a dir, un byte el valor és 0 a través 0177 sempre és un personatge en si mateix. Els caràcters que són més d'un byte han de començar sempre amb un byte en el rang des del 0200 final 0377.

El valor de byte 0 s’utilitza sovint en una cadena de caràcters ASCII.

L'especificació de les seqüències de bytes bàsics que representen caràcters únics dóna automàticament significats a moltes seqüències de bytes més llargues, com a més d'un caràcter. Per exemple, si la seqüència de dos bytes 0205 049 significa la lletra grega alfa, 0205 049 065 ha de ser una alfa seguida d'una`A '(Codi ASCII 065) i 0205 049 0205 049ha de contenir dues alfes seguides.

"Si qualsevol seqüència de bytes pot tenir més d’un significat com a seqüència de caràcters, el codi multibyte és ambigu i no és bo."

A la majoria de codis, hi ha certes seqüències d’octals que no tenen significat com a caràcter. Es diu que no són vàlids .

Un caràcter multibyte és un caràcter compost per seqüències d'un o més bytes. 

Cada seqüència de bytes representa un únic caràcter en el joc de caràcters estesos. Els caràcters multibyte s'utilitzen en jocs de caràcters com ara Kanji.

Els caràcters amples són codis de caràcters multilingües amb un ample invariable de 16 bits. El tipus de les constants de caràcters és char; per als caràcters amples el tipus és wchar_t. Com que els caràcters amples sempre són de grandària fixa, amb els caràcters amples es simplifica la programació amb jocs de caràcters internacionals.

El literal de cadena de caràcter ample L "Hola!" es converteix en una matriu de sis sencers de tipus wchar_t.

{L'H', L'o', L'l', L'a', L'!', 0}

 

L'especificació Unicode és l'especificació de caràcters amples. Les rutines de la biblioteca en temps d'execució per traduir caràcters multibyte i amples inclouen mbstowcs, mbtowc, wcstombs i wctomb.

Més informació ->  Estructures stdlib

Més informació -->  Manipulació memòries multibytes

Més informació ->  llibreria <stdlib.h>

Més informació ->  The GNU C Library - Extended Characters

Funcions stdlib [8/9]: qsort, bsearch

Manipulació d'arrays:

Funció qsort:     void qsort(void *llista, size_t nmemb, size_t tamany,                                               int(*cmpfunc)(const void*, const void*));

Ordena una matriu.

*llista: és el punter al primer element de la matriu que s’ordenarà.

nmemb: és el numero de elements en la matriu apuntats per base.

Tamany: és el tamany en bytes de cada element de la matriu.

*cmpfunc: és la funció que compara dos elements.

Aquesta funció no retorna cap valor. 

Funció bsearch:   void *bsearch(const void *clau, const void  

                           *llista, size_t nitems, size_t tamany, int (*cmpfunc)(const

                            void *, const void *));

Busca en una matriu de nitems, el membre inicial del qual s’apunta per llista, para un membre que coincidies amb el objecte apuntat per clau. El tamany de cada membre de la matriu s’especifica per tamany.

El contingut de la matriu te que estar en ordre ascendent d’acord amb la funció de comparació a la que fa referencia compar.

*clau: és el punter al primer element de la matriu que comparara per trobar.

llista: és el numero de elements en la matriu apuntats per base.

Nitems: és numero de items que te el array

Tamany: és el tamany en bytes de cada element de la matriu.

*cmpfunc: és la funció que compara dos elements.

Més informació -> llibreria <stdlib.h>

Funcions stdlib [7/9]: calloc, malloc, realloc i free

 Gestió de memòries dinàmiques:

Funció calloc:     void *calloc(size_t nmemb,size_t tamany);

Adjudica espai para un array de nmemb objectes, cada qual te com a tamany tamany. 

El espai es inicialitzat a cero.

La funció calloc retorna o be un punter nul o be un punter al espai adjudicat.

Funció malloc:     void *malloc(size_t tamany);

Adjudica espai para un objecte, del qual el tamany es especificat per tamany del qual el valor es indeterminat.

La funció malloc retorna un punter nul o un punter al espai adjudicat.

Funció realloc:     void *realloc(void*ptr,size_t tamany);

Canvia el tampany del objecte apuntat per ptr al tamany especificat per tamany. 

Pot multiplicar, dividir, sumar i restar espais de memoria a una estructura.

El contingut del objecte no canviarà fins el menor dels tamanys nous i vells. Si el tamany nou es major, el valor de la porció novament adjudicada del objecte es indeterminat.

Si ptr es un punter nul, la funció realloc se comportarà a igual que la funció malloc para el tamany especificat. De lo contrari, si ptr no es igual a un punter prèviament retornat por la funció free, o realloc, el comportament no esta definit.

Si el espai no pot ser des adjudicat, el objecte apuntat per ptr no varia.

Si tamany es 0 i ptr no es un, el objecte al que apuntala es alliberat.

La funció realloc retorna o be un punter nul o be un punter possiblement al espai adjudicat mudat.

Funció free:     void free(void*ptr);

Causa el espai apuntat per ptr a ser des adjudicat, per lo que la memòria tornarà a ser disponible per a una altra adjudicació.

Si ptr es un punter nul, no es realitzarà cap acció. De lo contrari, si el argument no correspon a un punter prèviament retornat per la funció calloc, malloc o realloc, o si el espai ha sigut des adjudicat per una crida a fre o realloc, el comportament no serà definit.

La funció free no retorna ningun valor.

Més informació -> llibreria <stdlib.h>

Funcions stdlib [6/9]: strtod, strtol, strtoul

 Representar strings com a valor d'altres variables:

Funció strtod:     double strtod(const char *numPtr, char**finalPtr);

Converteix la porció inicial de una cadena apuntada per numPtr a una representació de long int. 

Primer descomposa la cadena de entrada en tres parts: una seqüencia inicial, possiblement buida, de caràcters de espai en blanc(tal com es especificat per la macro isspace), una seqüencia Font semblant a una constat de coma flotant; y una cadena final de un o mes caràcters irreconeguts, incloent el caràcter nul final de la cadena d’entrada.
Llavors, intenta convertir la seqüencia Font a un numero de coma flotant i retorna el resultat.

La forma expandida de la seqüencia Font es un signe, positiu o negatiu, opcional, seguint una seqüencia de dígits opcionalment contenint un caràcter de la coma decimal (sol ser un punt), seguint una part exponent opcional, però sense incloure un sufix de coma flotant.
La seqüencia font esta definida com la conseqüència inicial mes llarga de la cadena de entrada, començant per el primer caràcter que no es un espai en blanc, que és de la forma esperada. La seqüencia font no conte caràcter si la cadena de entrada esta buida o consisteix completament de espais en blanc, o si el primer caràcter que no es un espai en blanc, es diferent a un signe, un dígit, o un caràcter de la coma decimal (o punt decimal). Si la seqüencia font te la forma esperada, la seqüencia de caràcters començant per el primer dígit o el caràcter de la coma decimal (qualsevol que aparegui primer) es interpretat com una constant de com flotant, excepte que el caràcter de la coma decimal es usat en lloc de la coma, y si no apareix la part exponent ni el caràcter de la coma flotant, la coma decimal es assumit que segueix el últim dígit de la cadena.

Si la seqüencia font comença amb un signe negatiu, el valor resultant de la conversió es negatiu. Un punter a la cadena final es guardat en el objecte apuntat per finalPtr, amb la intenció de que finalPtr no es nul.

A continuació, se mostra el formato usat por esta funció:


[eb] [sn] [ddd] [.] [ddd] [e[sn]ddd]

on:

[eb] Espai en blanc opcional

[sn] Signe opcional (+ ó -)

e 'e' ó 'E' opcional

[.] Coma decimal opcional (punto decimal)

[ddd] Dígits opcionals.

Funció strol:     long int strol(const char *numPtr, char **finalPtr, int base);

Strtol: converteix la porció inicial de la cadena apuntada per numPtr a una representació de long int.

Primer descompon la cadena d'entrada en tres parts: una seqüència inicial, possiblement buida, de caràcters d'espai blanc (tal com és especificat per la funció isspace), una seqüència font assemblant-se a un enter representat en alguna base determinat pel valor de base , i una cadena final d'un o més caràcters irreconeguts, incloent el caràcter nul final de la cadena entrada. Llavors, intenta convertir la seqüència font a un sencer, i retorna el resultat.

Si el valor de base és zero, la forma esperada de la seqüència font és aquella d'una constant sencera, opcionalment precedida per un signe més o menys, però sense incloure un sufix sencer. Si el valor de base està entre 2 i 36, la forma esperada de la seqüència font és una seqüència de lletres i dígits representant un sencer amb una base especificat per base, opcionalment precedida per un signe positiu o negatiu, però sense incloure un sufix sencer .

Les lletres de a (o A) fins z (o Z) són atribuïts els valors de 10 a 35; només lletres els valors atribuïts són menors que aquells de la base estan permesos. Si el valor de base és 16, els caràcters 0x o 0X pots opcionalment precedir la seqüència de lletres i dígits, a continuació> de el signe, si aquest està present.

La seqüència font està definida com la seqüència inicial més llarga de la cadena d'entrada, començant pel primer caràcter que no és un espai blanc, que és de la forma esperada. La seqüència font no conté caràcters si la cadena d'entrada està buida o consisteix completament d'espai en blanc, o si el primer caràcter que no és un espai blanc és diferent a un signe o lletra o dígit permès.

Si la seqüència font té la forma esperada i el valor de base és zero, la seqüència de caràcters començant pel primer dígit és interpretada com una constant sencera. Si la seqüència font té la forma esperada i el valor de base està entre 2 i 36, és usada com la base per a la conversió, atribuint a cada lletra el seu valor donat tal com descrit anteriorment. Si la seqüència font comença amb un signe negatiu, el valor resultant de la conversió és negatiu. Un punter a la cadena final és guardat en l'objecte apuntat per finalPtr, per tal que finalPtr no és nul. Si la seqüència font està buida o no té la forma esperada, cap conversió és realitzada; el valor numPtr és guardat en l'objecte apuntat per finalPtr, per tal que finalPtr no és nul.

A continuació, es mostra el format usat per la funció:

[eb] [sn] [0] [x] [ddd],on:

[eb] espai en blanc opcional Cita en bloc

[sn] Signe opcional (+ ó -)

[0] Cero opcional (0)

[x] 'x' ó 'X' opcional

[ddd] Dígits opcionals

 Si base es cero, los primers caràcters de numPtr determinen la base:

Primer caràcter -----Segon caràcter ----- Cadena interpretada com...

0 ------------------------- 1 a 7 ------------------------- Octal

0 ------------------------- x ó X ------------------------- Hexadecimal

1 a 9 ---------------------(0 a 9) ------------------------ Decimal

La funció strtol retorna el valor convertit, si de cas existeix. Si no es va poder realitzar cap conversió, zero és retornat. Si el valor correcte no pertany a l'interval de valors representables, LONG_MAX o LONG_MIN és retornat (segons el signe de la valor), i el valor de la macro ERANGE és guardat en errno.

----------------------------------------------------------------------------------------

strtol et permet transformar un numero d'un string usant el teorema fonamental de la numeració per retornar-nos el valor segons la base a decimal i guardar el resultat en una memoria long int.

Per exemple:

Transformar i guardar un string amb valor binari en decimal:

Transformar i guardar un string amb valor decimal en decimal:

Transformar i guardar un string en base hexadecimal en decimal:

Funció strtoul:     unsigned long int strtoul(const char *numPtr, char **finalPtr, int base);

Converteix la porció inicial de la cadena apuntada per numPtr a una representació de unsigned long int.

La funció strtoul funciona idènticament a la funció strtol.

La funció strtoul retorna el valor convertit, si existeix. Si no s’ha pogut realitzar cap conversió, retornarà 0. Si el valor correcte no pretereix al Interval de valors representables, UONG_MAX es retornat, i el valor de la macro ERANGE es guardat a errno.

Més informació -> llibreria <stdlib.h>

Funcions stdlib [5/9]: div, ldiv

Almatzenar resultats d'una divisió:

Funció div:     div_t div(int num, int denom);

Calcula el quocient i el residu de la divisió del numerador num entre el denominador denom Si la divisió es inexacta, el quocient resultant es el enter de menor magnitud, que es el mes pròxim al quocient algebraic. Si el resultat no pot ser representat el comportament no serà definit, del contrari, quot* denom + rem igualarà num.

La funció div retorna la estructura div_t, contenint el quocient i el residu.
La estructura conte els següents membres:

• int quot; // quocient
• int rem; // residu

Funció ldiv:     ldiv_t ldiv(long int num, long int denom);

Similar a la funció div, excepte que els arguments son de tipus long int. La funció ldiv retorna la estructura de tipo ldiv_t, que conte el quocient i el residu amb valor long int.

Més informació ->  Estructures

Més informació ->  llibreria <stdlib.h>

Funcions stdlib [4/9]: rand, srand

Generar numeros aleatoris:

Funció rand:     int rand(void);

La funcio rand calcula una seqüencia de numeros enters pseudo-aleatoris
en el inverval de 0 al valor de la macros RAND_MAX

La funcio rand retorna un enter pesudo-aleatori.

Funció srand:     void srand(unsigned int llavor);

Utilitza el argument com una llavor para una seqüencia nova de números pseudo-aleatoris para ser retornats per crides posteriors a rand.

Si srand es llavors cridat amb el mateix valor de la llavor, la seqüencia de números pseudoaleatoris serà repetida, si rand es cridada abans de que hagen fet qualsevol crida a srand, la mateixa seqüencia serà generada com quant srand va ser cridada per primer cop amb un valor de llavor de 1. 

Les següents funcions defineixen una implementació portable de rand y srand.

La funció srand no retorna cap valor.

Més informació ->  llibreria <stdlib.h>