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:
/* 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:
/* 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:
/* 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:
/* 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:
/* 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:
/* 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