			--- APONTAMENTOS SOUBRE C ---

- \033[x;yH -
	Para posicionar o cursor num determinado local do ecr, em vez de
utilizar a instruo "GOTO" (por exemplo: "goto(5, 5);") utilize "\033[x;yH"
dentro da funo "printf" (por exemplo: "printf("\033[5;5HFernando");"). Em
relao  instruo, o "\033" dentro da funo "printf" significa que se vai
dar um comando do tipo interpretavel pelo device ANSI.SYS. O "5;5" so as
cordenadas onde se ir posicionar o cursor no ecr. O "H" significa que a
instruo tipo ANSI ' relativa ao cursor. O "Fernando" ' um texto como outro
qualquer.

- \033[I;L;Fm -
        Este  um tipo de instruo identica  instruo "\033[x;yH" mas que
diz respeito  cr do texto que lhe segue, fazendo essa indicao o "m"
minsculo. O "I;L;F" so a intensidade, cr das letras e cr de fundo,
respectivamente. Exemplo: "printf("\033[1;31;43mFernando");". Pode-se
encontrar os nomes dos respectivos nmeros das cores no HELP do DOS relativo
ao ANSI.SYS.
        Existem tambm outras instrues do tipo "\033" com terminaes em
D, B, ...

                  --- BORLAND C++ 4.0 (da Makron Books) ---

- OS NOVE COMPONENTES BSICOS DE UM PROGRAMA -
        * Os programas precisam obter informaes de alguma fonte de entrada.
        * Os programas precisam decidir como esta entrada ser arranjada e
armazenada.
        * Os programas precisam utilizar um conjunto de instrues para
manipular a entrada. Estas instrues podem estar divididas em 4 grandes
categorias:
                * Comandos nicos
                * Comandos condicionais
                * Laos
                * Sub Rotinas
        * Os progrmas precisam informar os resultados da manipulao de
 dados.
        * Um aplicativo bem escrito incorpora todos os fundamentos listados,
expressos em um bom projecto modular, cdigo autodocumentado (por exemplo,
nomes de variveis significativos) e um bom esquema de identao.

Resumindo em 3 componentes bsicos obtem-se o:
        Diagrama EPS (Entrada/Processamento/Sada).

O C tem 77 palavras-chave.

- COMPILADOR C/C++ -
        *.C e *.CPP - Ficheiros de C (ao salvar-se o cdigo fonte),
        *.OBJ - arquivos objecto (ao fazer-se a montagem),
        *.EXE - arquivos executaveis (ao fazer-se a ligao).

- TURBO ASSEMBLER -
        *.ASM - Ficheiros de Assembly,
        *.OBJ - arquivos objecto (na montagem),
        *.EXE - arquivos executaveis (na ligao).

- MENU -
  View:
        Breakpoint - Define pontos onde o programa deve parar,
        Watches - monotoriza variaveis,
        Variables - nomes das variaveis acessiveis actualmente por seu
  programa.
  Run:
        Goto cursor - Executa o programa at ao lucal do cursor,
        Trace into - executa uma nica linha,
        Step over - uma nica linha (salta as funes),
        Program reset - recarrega para deporao,
        Delete All - remove todos os breakpoints.

printf("%d", i); ("%d"  a string de formato.)

& - Operador de endereo: Sempre que uma variavel  precedida por este o
valor utilizado passa a ser o endereo da variavel especifica.

- CARACTERES ESPECIAIS -
        \a - bel,
        \b - volta um passo a trz,
        \f - salta pgina, 
        \r - retorno de carro,
        \t - TAB,
        \v - TAB vertical,
        \\ - barra invertida,
        \' - apostrofo,
        \" - aspas,
        \? - interrogao,
        \0 - caracter nulo,
        \n - passa para a linha de baixo.

- DEFINIDORES DE TIPOS -
        %hd,
        %ld,
        %lf,
        %LF,
        %c - um caractere,
        %d - inteiro decimal,
        %e - double/float em notao cientifica,
        %f - double/float em decimal,
        %o - octal,
        %s - string de caracteres,
        %u - int decimal,
        %x - hexadecimal (em minusculas),
        %X - hexadecimal (em maiusculas),
        %ed,
        %.2f.

- ARQUIVOS -
        int salario;
        FILE *Arq_ent;

        Arq_ent = fopen("A:\\RENDA.DAT", "r");

        fscanf(Arq_ent, "%d", &salario);

        fprintf(Arq_saida, "Fernando ", Nome2);

        * Modos de arquivo vlidos:
                r - Abre para leitura,
                w - abre para gravao,
                r+ - abre para actualizao de leitura ou gravao,
                w+ - cria para actualizao,
                a - abre para edio ou cria para gravao (se no existir),
                a+ - abre para edio actualizao no fim deste ou cria para
gravao (se no existir),
                rb - abre arquivo binrio para leitura,
                wb - abre arquivo binrio para gravao.

- IDENTIFICADORES, PALAVRAS-CHAVE -
        Palavra-chave: Identificador predefinido. Ex.: Float - identificador
predefinido como tipo.
        Tipos de dados: Char, int, float, double e enum.
                Int: Short int, long int, unsigned int, long, ...
                Double: long double, ...

        O subtipo "unsigned" pode ser usado pelos tipos:
                char e int (long e short int).

- FUNES -
        Chamada por valor -  quando  uma cpia de uma variavel de uma
funo para outra variavel de outra funo.
        Chamada por referencia -  quando a funo chamada usa as variaveis
originais da funo que chama.
        :: -  o operador de definio de escopo (para variaveis com escopo
no arquivo).

- ARGUMENTOS DE FUNO -
        * Formais (os de destino na funo),
        * reais (os originais).

- PARAMETROS DE UM PROGRAMA -
        void main(int argc, char *argv)
        {
                int i, n_int, n_float;

                printf("%s", argv[i]);
                n_int = atoi(argv[i]);
                n_float = atof(argv[2]);
        }

- INLINE -
        Sugere ao compilador para por uma funo em cada linha que a usa
(aumentando a velocidade). Esta tem que ser pequena e no pode ter um lao
for.

- SOBRECARGA DE UMA FUNO -
         quando uma funo tem o mesmo nome que outra, mas os argumentos so
diferentes ou retorno diferente, sendo assim vlida.

- OPERADOR VRGULA -
        Avalia duas expresses onde a sintaxe permite somente uma:
                for(min=0, max=10; min<max; min++, max--);

- CATEGORIAS DAS BIBLIOTECAS -
        Rotinas de classificao,
        de converso,
        de controle de directrios,
        de diagnstico,
        grficas,
        de entrada/sada,
        de interface (DOS, 8086, Bios),
        de manipulao,
        matematicas,
        de alocao de memria,
        de controle de processo,
        padres,
        de tela de janelas de texto e
        de data e hora.

- COMANDOS CONDICIONAIS -
        if-else,
        if-else-if,
        ?:,
        switch.

        x = Teste ? y: y*y; // Se "x" for igual a "Teste" ento "y" de outro
                               modo "y*y".

- COMANDOS/FUNES ESPECIAIS -
        break,
        continue e
        exit.

- COMANDOS DE LAO -
        for,
        while,
        do-while.

- atexit(); -
        Executa a funo definida com argumento nesta.
        ex.: atexti(funcao_a_executar);

- CAST'S -
        resultado = valor1 + (float) valor2 / (float) valor3;

- ESCOPO DE VARIAVEIS/FUNES -
        auto e register - vida local,
        static e extern -  vida global.

        static - s para o mesmo arquivo,
        extern - para alm do arquivo fonte,
        register - guarda a variavel num registo, optimizando a velocidade e
espao que usa na memria.

- OPERADOR DE ATRIBUIO -
        resultado = a + b; // "="  o operador de atribuio.

- OPERADORES DE ATRIBUIO COMPOSTOS -
        +=,
        -=,
        *=,
        /=.

- OPERADORES RELACIONAIS -
        ==,
        !=,
        >,
        <,
        >=,
        <=.

- OPERADORES LGICOS -
        && - E,
        || - OU,
        ! - NO.

- OPERADOR CONDICIONA (?:) -
        condicao ? expressao_verdadeira : expressao_falsa;

        Qualquer expresso if-else pode ser sunstituida por "?:".

- LISTA DE SMBOLOS -
        ++,
        --,
        ==,
        &&,
        ||,
        <<,
        >>,
        >=,
        <=,
        +=,
        -=,
        *=,
        /=,
        ?:,
        ::,
        /*,
        */,
        //.

- ENUMERAES -
        enum pressao_t {
                OK,
                BAIXA,
                ALTA = 3 };
        pressao_t tanque1;

        ...

        tanque1 = BAIXA; // "BAIXA" assume o valor 1.

- CONST/VOLATILE/#DEFINE -
        const - so constantes, durante o decorrer do programa os seus
valores so inalteraveis.
              Ex.: const int i=9;

        volatile - so variaveis que se pode modificar o seu conteudo
inesperadamente, ou seja, outros programas em memria podem alterar o
conteudo destas sem o buffer do programa saber.
              Ex.: volatile int temporiz;

        const volatile - pelo contrrio, estas variaveis negam o acesso a
outros programas, ou seja, no podem ser modificadas inesperadamente (as
variaveis normais podem ser modificadas inesperadamente, mas o programa pode
travar, devido a haver uma corrupo dos dados esperados).
              Ex.: const volatile temporiz_const; // No pode ser modificada
                                                  // inesperadamente.

        #DEFINE - so constantes definidas fora do cdigo fonte, ou seja,
quando o preprocessador encontra a directiva "#DEFINE", troca no cdigo-fonte
ocorrncias VOLUME por 10.
              Ex.: #DEFINE VOLUME 10 // Constante "VOLUME" assume o valor 10.
            
- MODIFICADORES -
        pascal - define funo ou variavel do tipo de pascal.
                        Ex.:
                                int pascal minhatab[10];
                                int pascal minhafunc(int a, long b) { ... }
                                resultado = minhafunc(a, b, c);

        cdecl - evita que uma funo/variavel seja de tipo pascal.
                        Ex.:
                                int cdecl minhafunc(int a, long b); { ... }

        near, far, huge - modificam o tamanho de um ponteiro para objectos de
dados.
                near - 2 bytes,
                far - 4 bytes,
                huge - 4 bytes (endereamento de far).

- FUNES -
        void minhafuncao(int x, float y, ...); // Tem um n variavel de
                                               // argumentos (devido a "...").

        z = x * y * (::c); // a variavel "c" tem escopo no arquivo/geral.

- MATRIZES -
        So variaveis indexadas:

        4 propriedades bsicas de uma matriz:
                * Os itens de dados individuais na matriz so chamados de
                elementos.
                * Todos os elementos devem ser do mesmo tipo de dado.
                * Todos os elementos so armazenados contiguamente na memria
                do computador, e o subscrito (ou indice) de o primeiro
                elemento  o zero.
                * O nome da matriz  um valor constante que representa o
                endereo do primeiro elemento na matriz.

        sizeof - No retorna um tipo int, em vez disso sizeof retorna um tipo
        size_t. Use: (int) sizeof(argumento);

        Inicializando matrizes:
                * Por padro (o computador inicializa a matriz com um valor
                binrio: 0).
                * Explicitamente (na declarao desta).
                * Durante a execuo do programa.

        Uma matriz com uma declarao de tamanho vazia e nenhuma lista de
valores tem um comprimento nulo, ex: int a[];

        & - Operador endereo.

        printf("%x", &var); --> FF32 - morada da variavel em formato HEX.

        gets - Converte o caracter de nova linha para um nulo.
        puts - Converte nulo em um caracter de nova linha.
        fgets - Retem '\n' e adiciona '\0'.
        fputs - Retem '\n' e imprime at '\0'.
        sprintf - sprintf(destino, "nome %i", "s"); -->  igual a "printf" s
que guarda resultado na string destino.
        strcpy - string copy, strcpy(d, o); -->  igual a "printf" s que
guarda resultado na string destino.
        strcat - string concunates - strcat(d, o); --> Junta O a D.
        strcmp  - string compare - strcmp(d, o); Compara O a D, retorna um
valor int;
        menor que 0 se "O" for maior que "D", maior que 0 se "O" for menor
que "D", e 0 se "O" for igual da "D".
        strlen - string lenght - strlen(var); --> Retorna o nmero de
caracteres da string VAR.

- PONTEIROS -
        So variaveis que acessam outras variaveis atravez do seu endereo de
memria.

        * - Desreferenciador de um ponteiro.
        & - Operador de indereo.

        Y                 X
   |   10   | <----- |  0318  |         // X aponta para Y.
     [0318]

int valor1;        int_ptr:  do tipo int * e aponta para a morada &valor1.
int *int_ptr = &valor1;

         proibido obter moradas com aritmetica de ponteiros e o endereador
simultaneamente: &valor1+10; // ilegal.

        Aritmetica com ponteiros:
                 s permitido com os operadores: ++, --, + e -.
                     ex: float_ptr+=2;       // Retorna a morada do 3 float.

        O que se pode fazer com ponteiros:
                * Subtrair um inteiro de outro.
                * Subtrair dois ponteiros (apontam para o mesmo objecto).
                * Comparar ponteiros usando operadores relacionais (<=, >,
        ==, ...).

        Tamanho dos ponteiros:
                Por padro um ponteiro  near (est dentro dos primeiros
        64Kb).

        Formato dos endereos nos ponteiros:
                segmento:deslocamento.
                segmento - caixa.
                deslocamento - gaveta da caixa.

        huge e far - Fora o ponteiro a ter segmento:deslocamento.
        near - tem s deslocamento ( mais rpido).

        Ponteiros de funo:
                int (*ptr_funcao)(int a, int b);

        "#var_int" - imprime o nome da variavel.

- ALOCAO DINMICA DE MEMRIA -
        malloc - Aloca um bloco contguo de armazenagem para o objecto
especificado e ento retorna um ponteiro para o inicio do bloco.
        float_ptr = malloc(num_floats = sizeof(float));
        // O parametro de malloc obtem os espaos em bytes.

        free - Retorna a memria alocada previamente para o heap,
permitindo que a poro da memria seja realocada.

                free(float_ptr);

        Ponteiros do tipo void - So ponteiros de um tipo desconhecido.
                void *ptr_void;
                ptr_void = new char[40];
                printf("*(char *)ptr_void);

        new - identico a malloc:
                bloco_de_mem_ptr = new int[num];

        delete - identico a free:
                delete(float_ptr);

- TIPO DE REFERENCIA EM C++ -
        int& valor2 = valor1;

        "valor2" funciona como se fosse "valor1". E este tipo tem de ser
inicializado na declarao.

        Quando utilizar tipos de refrencia:
                * Torna o cdigo mais legvel, permitindo que voc ignore os
detalhes de como um parmetro  passado.
                * Os tipos de referncia colocam a responsabilidade da
passagem de argumentos sobre o programador que escreve as funes e no no
indivduo que os utiliza.
                * Estes so correspondentes necessrios para a sobrecarga de
operadores.
              
- ENTRADA E SADA EM C/C++ -
        H 3 tipos bsicos de funes de E/S: Alto Nvel, Consola e Porta,
e Baixo Nvel.

        Todas as funes de E/S de Alto Nvel tratam os arquivos de dados ou
itens de dados como um canal (ou fluxo) de caracteres indivduais.

        FILE * - Ponteiro file (ponteiro de arquivo/canal)
        canal = stream.

        Todas as funes de Alto Nvel oferecem bufferizao: Um arquivo
bufferizado fornece um local de armazenagem intermediria para toda
informao que  retirada ou enviada para o arquivo. A E/S de disco consome
muito tempo mas a bufferizao agiliza seu aplicativo. As funes de E/S de
Alto Nvel acessam os dados um bloco por vez (em vez de um caracter ou
estrutura por vez).

        EOF - Valor verdadeiro retornado no final do arquivo.
        NULL - Ponteiro nulo (aponta para nada).
        BUFSIZ - Define o tamanho padro, em bytes, dos buffers de arquivo.

        entrada = fopen("AMOSTRA.DAT", "r");

        TABELA 11.1 (Funes de E/S de Alto Nvel comuns em C) - p.343

        Quando seu aplicativo comea a ser executado, 5 arquivos j esto
abertos automaticamente: stdout, stdin, stderr, stdprn, stdaux.

        < - redireciona a entrada (por padro  o teclado).
        > - redireciona a sada (por padro  o monitor).

redirec < teste.dat             // Usa "teste.dat" em vez do teclado.
redirec > sai.dat               // Imprime na sada sai.dat.
redirec < teste.dat > sai.dat   // L de "teste.dat" e imprime em "sai.dat".

        estagio1 | estagio2 - canaliza "estagio1" por "estagio2".

- MODIFICANDO O BUFFER DE ARQUIVO -
        setbuf, setvbuf.

- FECHANDO UM ARQUIVO -
        fclose, fcloseall.
        feof - (Function End Of File, retorna verdadeiro em fim de ficheiro).

        E/S de baixo nvel (no bufferizada) - p.348.

- FUNES DE CARACTERE -
        getc, putc.
        fgetc, fputc (identicas s macros correspondentes "getc" e "putc").

        getchar, putchar (identicas a getc/putc mas direcionadas a stdin/stdout).
        fgetchar, fputchar (identicas s suas macros correspondentes).

        getch, putch (funes verdadeiras, de baixo nvel, sem bufferizao).

- FUNES DE STRING -
        fgets, fputs:
                fgets(string, max_n_de_ch + nulo, arq_ent);
                fputs(string, stdout);

        gets, puts (macros correspondentes de fgets/fputs).

- FUNES PARA INTEIROS -
        getw, putw (l de ficheiro binrio um caracter, p.354).

- SADA FORMATADA -
        printf, fprintf:
                printf("%020f", pi);    // 000...0003.141593

- FSEEK, FTELL E REWIND -
        fseek - posiciona o ponteiro FILE.
        ftell - indica onde esta o ponteiro FILE.
        rewind - posiciona o ponteiro FILE para o inicio do arquivo.
                        p.361.

- SCANF, FSCANF E SSCANF -
        scanf("%2d %5s %4f", &int_valor, string, &real);

        %[A-Za-z] - string de valores entre A-Z e a-z.

        fscanf - requer a especificao de um ficheiro de entrada.
        sscanf - L os dados de uma matriz.

        scanf("%[^A-Za-z]", string); // Recebe uma string que contenha tudo
                                     // menos de A-Z e a-z. O "^" especifica
                                     // no usar.

        scanf("%*[ \t\n]%S", string); // L qualquer espao em branco mas no
                                      // grava numa string, e l uma string e
                                      // grava em "string".

- CIN, COUT E CERR (P.383) -
        cout << "Um nome";              // stdout obtem "Um nome".
        cin >> nome;                    // stdin passa para nome.
        cin.get(nome, tamanho, '*');    // Le tamanho caracteres em nome ou
                                        // at "*" ou "\n", o que vier 1.

        cout << (int) letra;
        cout << (char) 90;
        cout << oct << valor_int;

        cout.write(string1, s);

        cout.width(3);
        cout << valor_int;
        cout.setf(ios::left);

        cout.setf(ios::uppercase);
        cout << hex << valor_int;
        cout.unsetf(ios::uppercase);
        cout << dec     // Retorna para base dcimal.

        cout.setf(ios::showpos);
        cout << valor_int;
        cout.unsetf(ios::showpos);
        cout.unsetf(ios::left);

- ENTRADA E SADA EM ARQUIVO -
        ifstream minhaent("a:\\minhaent.ent", ios::in);
        ofstream minhasai("a:\\minhasai.sai", ios:out);

        minhaent.get(ch);
        minhasai.put(ch);

        minhaent.close();
        minhasai.close();

        ifstream um_arq_ent;

        um_arq_ent.open("vendas01");

        um_arq_ent.close();

        fstream io("actual.dat", io::in | ios::app);    // fstream - para e/s.

        seekg ou seekp - reposico do ponteiro FILE (p.391).
        Tipos de erros de arquivos - p.393.

        cin.get(string, 80, '.'); // L dados para "string" at o "\n" ou
                                  // "." mais proximo.

- ESTRUTURAS, UNIES E ITENS DIVERSOS -

        Estrutura:
                struct tipo {
                        tipo var1;
                        tipo varN;
                };
                struct tipo var;
                struct tipo var[max];   // Matriz de estruturas.
                struct tipo *var;       // Ponteiro para estrutura.

                gets(var.tipo var1);
                gets(var[n].tipo varN);

                varptr = &var_struct;

                scanf("%s", &varptr -> tipo varN);
                varptr++;

        Unies:
                Union todos_tipos {
                        char c;
                        int i;
                        float f;
                        double d;
                } tdados;

                tdados.c = 'b';         // Recebe b, em int tem outro valor.

        typedef (definio de tipos):
                typedef int inteiro;

                inteiro i = 50, n2, valor_int = 0;

        enum:
                enum meses_t {
                        jan=1, fev, mar, abr, mai, jun, jul, ago, set, out,
                        nov, dez
                } mes;

                mes = mar;      // "mar"  como se fosse o n 3.

        Listas ligadas:
                Para quando se quer passar estruturas de dados dinamicamente
        para a memria, p.421.
                Uma lista ligada  quando o ltimo elemento de uma estrutura
        aponta para outra.

- CLASSES -
        Sintaxe:

        class tipo {
                tipo var1;
                tipo varN;
        public:
                funcao-membro1(var's)
                funcao-membroN(var's)
        } nome_associado_ao_tipo_de_classe;
        tipo_classe nome_associado;

        tipo_retorno tipo_classe::funcao-membro1(var's)
        {
                ...
        }

        main()
        {
                nome_associado.funcao-membro(var's)

        }

        Uma classe pode ter estruturas:

        class tipo {
                struct tipo {
                        var's
                } nome;

        public:
                ...
        }

        Construturas/Destroturas:
                * Construtura - usada para inicializar variaveis e alocar
        memria.
                * Destrotura - usada para desalocar a memria das variaveis.

                Se estas no forem especificadas na classe o compilador
        lerea-as automaticamente.

                class moedas {
                        int i;
                public:
                        moedas() { i=0; printf("Construtura"); } // Constru.
                        ~moedas() { cout << "fim!\n" }           // Destrut.
                        void pega_centavos(int);
                };

                moedas total;

                string (char *) { str=new char[TAM]; }
                ~string() { delete str; }

- A SOBRECARGA DE FUNES (p.454) -
         o uso (por exemplo) de duas funes iguais destinguidas unicamente
pelo tipo de dado que recebem.

- FUNO STRTOK -
        nome1 = strtok(str1, str2);

- FUNES AMIGAS -
        So aquelas que so definidas fora da classe mas que partilham da
informao da mesma.

        Sintaxe:

        classe tipo {
                friend valor_retorno funcao(var's);
                ...
       public:
                ...
        }

- PONTEIRO THIS -
        this - palavra-chave.

         auto-referenciado (referencia automticamente a classe para onde
foi definido).

        Sintaxe:

        minhaclasse *this;
        minhaclasse classeX;

        this -> ch;     // ch  dentro da classe;

        Sintaxe:

        tipo operator opr(lista_de_parametros);

        operator - palavra-chave.

- CLASSES DERIVADAS -
        So classes que esto dentro de outras, mas  como se fossem a mesma.

        Sintaxe:

        class emprestimo::public cliente {   // "cliente  a classe base/me.
                ...
        public:
                ...
        }

- PROGRAMAO ORIENTADA A OBJECTOS -
         basiada em classes (so estas que constroiem os objectos).

        Encapsulamento:  a definio da estrutura interna, relacionamento e
algumas proteces de um objecto (normalmente todo feito numa classe).

        Hierarquia de classe:  quando h uma classe-me e subclasses-filhas.

        Herana:  quando  a derivao de uma classe para outra classe.

        Polimorfismo -  quando mensagens comuns podem ser enviadas para os
objectos de classe-raiz e todos os objectos da subclasse derivada.

        Funes virtuais - so aquelas que so definidas na classe-raiz.

        Tal como as funes, podem existir classes amigas (friend).

- TURBO DEBUGGER -
       Em:
        Menu View | Hierarchy | class hierarchy:
                Visualiza-se a estrutura das classes.

- APROVEITANDO AS BIBLIOTECAS DAS LINGUAGENS C E C++ -
        Principais arquivos de cabealho:
                bios,
                complex,
                conio,
                ctype,
                dos,
                graphics,
                io,
                iostream,
                math,
                stdio,
                stdlib,
                string e
                time.

        qsort - (Quick-Sort) para a organizao de dados nmericos.
        bsearch - para procurar numa matriz um dado:
                bsearch(&procurar, matriz, 9, sizeof(int), int_comp());

        Funes para caracteres:
                isalnum,
                isalpha,
                isascii,
                iscntrl,
                isdigit,
                isgraph,
                islower,
                isprint,
                ispunct,
                isspace,
                isupper,
                isxdigit,
                tolower,
                toupper. (is... - verifica, to... - traduz para).

        Funes para memria e string:
                memchr,
                memicmp,
                strchr,
                strcmpi,
                strspn,
                strdup,
                strerror,
                stricmp,
                strbrk,
                strrchr,
                strrev,
                strspn,
                strstr,
                strtok,
                strupr,
                strlwr.

        Recursos do sistema:
                em "bios.h":
                        bioscom,
                        biosdisk,
                        diosequip,
                        dioskey,
                        diosmemory,
                        diosprint,
                        diostime.

                em "graphics.h":
                        getmaxx,
                        getmaxy,
                        lineto,
                        graphresult,
                        grapherrormsg,
                        outtextxy,
                        setbkcolor,
                        setcolor,
                        setaspectratio,
                        getcolor,
                        getpalettsize,
                        setfillstyle,
                        moveto,
                        outtext,
                        getdrivername,
                        getmodename,
                        getbkcolor,
                        settextjustify.
