Memoria

[Be.Cool]

ola galera!!!
quando eu comecei a aprender sobre sockets me deparei com a função: memset()
e nas apostilas que eu tenho não explica sobre essa função!, procurei e achei umas funçoes muito interessantes
são elas:

Preenchendo um intervalo de memória com uma constante byte
memset()

prótotipo:
*memset(*STRING,CARACTER,BYTES)
a função acima preenche BYTES da área de memória apontada por *STRING com CARACTER . A função retorna um ponteiro para *STRING .

vamos ao exemplo de um código:

Code Select Expand

/* preechendo uma área de memória usando a função memset() */

#include <stdio.h>
#include <string.h>

int main()
  {
    char nome[10];

    memset(nome,'s',10);

    nome[10] = 0; /* inserindo o valor NULL para indicar o final da string */

    printf("%s\n",nome);

    return(0);
  }


esse foi um exemplo de memset.Agora vamos a sua irmã, memcpy



Copiando um intervalo de memória
memcpy()
prótotipo

*memcpy(*DESTINO,*ORIGEM,BYTES)
a função acima copia BYTES da área de meória *ORIGEM para a área de memória *DESTINO . A função retorna um ponteiro para *DESTINO . Exemplo:

Code Select Expand

/* copiando um intervalo de memória */

#include <stdio.h>
#include <string.h>

int main()
  {
    float nrs1[5] = {1.1,1.2,1.3,1.4,1.5};
    float nrs2[5] = {5,5,5,5,5};
    int contador;

    printf("valores de nrs1\n");
    for(contador = 0;contador < 5;contador++)
      printf("%.1f ",nrs1[contador]);
    printf("\n");

    printf("valores de nrs2 inicialmente\n");
    for(contador = 0;contador < 5;contador++)
      printf("%.1f ",nrs2[contador]);
    printf("\n");

    memcpy(nrs2,nrs1,sizeof(nrs1));
    /* observe o uso do operador "sizeof" para
     * determinar o tamanho da área de memória
     * a ser copiada
     */

    printf("valores de nrs2 após a cópia\n");
    for(contador = 0;contador < 5;contador++)
      printf("%.1f ",nrs2[contador]);
    printf("\n");

    return(0);
  }



Movendo um intervalo de memória
memmove()
prototipo:
*memmove(*DESTINO,*ORIGEM,BYTES)
a função acima move BYTES da área de memória *ORIGEM para a área de memória *DESTINO . A função retorna um ponteiro para *DESTINO . A diferença entre esta função e a função memcpy() mostrada na seção anterior é que com esta as área de memória *DESTINO e *ORIGEM podem se sobrepor. Exemplo:

Code Select Expand

/* movendo um intervalo de memória */

#include <stdio.h>
#include <string.h>

int main()
  {
    float nrs[5] = {1.1,1.2,1.3,1.4,1.5};
    float *ptr_nrs;
    int contador,bytes;

    printf("valores de nrs inicialmente\n");
    for(contador = 0;contador < 5;contador++)
      printf("%.1f ",nrs[contador]);
    printf("\n");

    ptr_nrs = nrs;
    ptr_nrs++;

    bytes = (sizeof(float) * 4);

    memmove(nrs,ptr_nrs,bytes);

    printf("valores de nrs após a movimentação\n");
    for(contador = 0;contador < 5;contador++)
      printf("%.1f ",nrs[contador]);
    printf("\n");

    return(0);
  }


Copiando até encontrar um byte específico
memccpy()
prótotipo:
*memccpy(*DESTINO,*ORIGEM,CARACTER,BYTES)
Ela copia, no máximo, BYTES de *ORIGEM para *DESTINO , parando se CARACTER for encontrado. Ela retorna um ponteiro para o próximo byte após CARACTER em *DESTINO ou NULL se CARACTER não for encontrado nos primeiros BYTES de *ORIGEM . Exemplo:

Code Select Expand

/* copiando um intervalo de memória até encontrar um
 * byte específico */

#include <stdio.h>
#include <string.h>

int main()
  {
    char frase[80] = "E como dizia meu velho professor de física...estudem!!!";
    char copia[80];
    char *ptr_copia;

    /* "ptr_copia" aponta para o resultado de memccpy().
     * Se o caracter "." for encontrado em "frase",
     * será efetuada a cópia da área de memória até
     * este caracter e "ptr_copia" apontará para o
     * próximo byte após "." em "copia.
     * Caso contrário, serão copiados 80 bytes e
     * "ptr_copia" receberá o valor NULL.
     */
    ptr_copia = memccpy(copia,frase,'.',80);

    if(ptr_copia)
      *ptr_copia = 0;

    printf("%s\n",copia);

    return(0);
  }





Comparando duas áreas de memória
memcmp()
prótotipo:
memcmp(*AREA1,*AREA2,BYTES)
Ela compara os primeiros BYTES de *AREA1 e *AREA2 .Se *AREA1 for maior ela retorna um inteiro maior que zero, se *AREA2 for maior ela retorna um inteiro menor que zero e caso as duas áreas sejam iguais ela retorna zero. Exemplo:

Code Select Expand

/* comparando duas áreas de memória */

#include <stdio.h>
#include <string.h>

int main()
  {
    char string1[7] = "aeiou";
    char string2[7] = "Aeiou";
    int resultado;

    printf("string1 = %s\n",string1);
    printf("string2 = %s\n\n",string2);

    resultado = memcmp(string1,string2,7);

    if(resultado > 0)
      printf("string1 é maior\n");
    else if(resultado < 0)
      printf("string2 é maior\n");
    else
      printf("string1 e string2 são iguais\n");

    return(0);
  }

  /* Faça algumas substituições no código
   * trocando o "A" maiúsculo de "string2"
   * para "string1" e/ou substituindo-o
   * por um "a" e observe os vários
   * resultados do programa.
   */



Trocando bytes adjacentes
swab()
prótotipo:
swab(*ORIGEM,*DESTINO,BYTES)
Ela copia BYTES de *ORIGEM para *DESTINO trocando os bytes adjacentes, pares e ímpares. Exemplo:

Code Select Expand

/* trocando bytes adjacentes */

#include <stdio.h>
#include <string.h>

int main()
  {
    char str_origem[30] = "Trocando bytes adjacentes";
    char str_destino[30];

    memset(str_destino,'s',30);

    str_destino[30] = 0;

    printf("str_origem  => %s\n",str_origem);
    printf("str_destino => %s\n",str_destino);

    printf("chamando swab()\n");

    swab(str_origem,str_destino,30);

    printf("str_origem  => %s\n",str_origem);
    printf("str_destino => %s\n",str_destino);

    return(0);
  }


bom é isso ai!!
bye