ABC++ | Choppnerd

int regexcmp(char *myregex, char *entrada) {
        /* aloca espaço para a estrutura do tipo regex_t */
        regex_t reg;

        /* compila a ER passada em (a)
         * em caso de erro, a função retorna diferente de zero
         */
        if (regcomp(&reg, myregex, REG_EXTENDED | REG_NOSUB) != 0) {
                fprintf(stderr, "erro regcomp\n");
                exit(1);
        }

        /* tenta casar a ER compilada (&reg) com a entrada
         *  se a função regexec retornar 0 casou, caso contrário não
         */
        return regexec(&reg, entrada, 0, (regmatch_t *) NULL, 0);
}// Fim da função

// exemplo de uso
//-----------------------------------------------------------------------------------
void main(int argc, char *argv[]){

        if(!regexcmp("<[[:alnum:]]+>", argv[1])){
                printf("Tem tags XML\n");
        }else{
                printf("Não tem tags XML");
        }
}

/*

Pessoal,



Todos que usam C e C++ com mais seriedade sabem que a utilização da

memória pode ser um problema.

Matreizes dinâmicas, ponteiros de char e tudo o mais que pode crescer

e explodir o programa.

Não seria bom se a linguagem C tivesse um recurso para controlar a

memória ? Em alguns projetos, sim. Em outros é bom ter um controle

manual da memória.

Tudo que é automático falha automaticamente.

Mas e se fosse possível usar este recurso sempre que for conveniente

sem perder o poder de poder fuçar na unha quando for necessário ?



Hmmmm agora estamos falando como programadores de verdade!



A linguagem C é extensível e existe como adicionar uma lib que faça o

sujo trabalho de coletar o lixo para nós.



Sim, a biblioteca de GC (Garbage Colector),  possui um algoritmo de

"limpeza" de memória e basicamente você não vai ficar perdido em meio

a funções free() não finalizadas e também vai ter uma indicação melhor

em tempo de execução se alguma área de memória explodiu, e onde.

Isso dá uma grande agilidade e poder de depuração.

Bom, as referências dessa lib: Está hospedada e mantida pela HP. É

usada no projeto Mozilla, Inkscape, Mono e vários projetos.

Abaixo um simples exemplo de programa devorador de memória alocada e

como ele fica simples feito com a lib.

Vejam que basta utilizar GC_MALLOC() no lugar do mal-loco() original

ou seja a lib possui interface com o esquema de alocação de memória

feito por programadores cabra-macho sim senhor.

E notem também que o free() foi pra /dev/null



*/



//Exemplo de utilização da biblioteca. loop.c



#include "gc.h"

#include <assert.h>

#include <stdio.h>



int main()

{

        int i;



        GC_INIT();    /* Optional on Linux/X86; see below.  */

        for (i = 0; i < 10000000; ++i)

        {

                int **p = (int **) GC_MALLOC(sizeof(int *));

                int *q = (int *) GC_MALLOC_ATOMIC(sizeof(int));

                assert(*p == 0);

                *p = (int *) GC_REALLOC(q, 2 * sizeof(int));

                if (i % 100000 == 0)

                        printf("Heap size = %d\n", GC_get_heap_size());

        }

        return 0;

}

//EOF



// Compilação:

// cc -I/home/xyz/gc/include loop.c /home/xyz/gc/lib/libgc.a -o loop



//Referencias da lib:

//http://www.hpl.hp.com/personal/Hans_Boehm/gc/

//http://www.hpl.hp.com/personal/Hans_Boehm/gc/simple_example.html

Choppnerd

Arquivos da Tag: ABC++

ABC++: Função que testa Expressão Regular.

ABC++ Coletando lixo do C (Garbage colector para C e C++)