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