codigo rapido

você já viu a função sscanf? Acho que ela poderia te ajudar. Se você usar um scanf normal pra colar tudo o que quer, na sequencia você usa um sscanf pra pegar as variaveis que você querseparadinhas e bonitinhas.

Eu tava pensando em casos em que se insere um dado e a deleção dele só acontece quando se abaixa uma flag nos dados, representando a exclusão. Nos casos em que se insere, imaginei que eu deveria já criar uma tabela vazia e ir adicionando o mais disperso possivel, para que se eu tiver a necessidade de inserir entre algum valor, eu ter os espaços vazios para ir jogando pra frente os que estiverem atrapalhando... Eu to cheio de ideias pra fazer uns programas sobre isso. É um assunto muito legal e interessante. Mas infelizmente o o pouco tempo que tenho vai me obrigar a deixar isso pra depois. Valeu! Ogrigado!

Antigamente existiam algumas formas de se hackear sites utilizando algumas vulnerabilidades, como injeção de código na linguagem do site ou na linguagem do banco de dados usado pelo site. O SQL injection era uma maneira interessante de pegar as tabelas de nomes e senhas de usuários. Existe forma de se fazer o mesmo em C? Se sim, quais caracteres eu devo fazer escape para evitar que algum hacker consiga fazer algo prejudicial ao sistema? Hoje eu fiz um url decode. Percebi que o GEdit tem iso-8859-1 para salvar meus arquivos .c, mas quando eu faço um locale, só aparece UTF-8. Então fiquei imaginando um cliente com o mesmo problema e que não queira atualizar sua maquina e fiz o seguinte programa: //fonte: http://tivideotutoriais.blogspot.com/2021/08/linguagem-c-url-decode-iso-8859-1.html char *matriz[16][16] = { {"^@","^A","^B","^C","^D","^E","^F","^G","^H","^I","<br>","^K", "^L","^M", "^N","^O"}, {"^P","^Q","^R","^S","^T","^U","^V","^W","^X","^Y","^Z","^[", "^\\","^]", "^^","^_"}, { " ", "!","\"", "#", "$", "%", "&","\'", "(", ")", "*", "+", ",", "-", ".", "/"}, { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", ":", ";","&lt;", "=","&gt;", "?"}, { "@", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O"}, { "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", "[", "\\", "]", "^", "_"}, { "`", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o"}, { "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", "{", "|", "}", "~","^?"}, { " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "}, { " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " ", " "}, { " ", "¡", "¢", "£", "¤", "¥", "¦", "§", "¨", "©", "ª", "«", "¬", " ", "®", "¯"}, { "°", "±", "²", "³", "´", "µ", "¶", "·", "¸", "¹", "º", "»", "¼", "½", "¾", "¿"}, { "À", "Á", "Â", "Ã", "Ä", "Å", "Æ", "Ç", "È", "É", "Ê", "Ë", "Ì", "Í", "Î", "Ï"}, { "Ð", "não", "Ò", "Ó", "Ô", "Õ", "Ö", "×", "Ø", "Ù", "Ú", "Û", "Ü", "Ý", "Þ", "ß"}, { "à", "á", "â", "ã", "ä", "å", "æ", "ç", "è", "é", "ê", "ë", "í", "ì", "î", "ï"}, { "ð", "não", "ò", "ó", "ô", "õ", "ö", "÷", "ø", "ù", "ú", "û", "ü", "ý", "þ", "ÿ"} }; int hex(char x) { if(x=='0'){ return 0;} if(x=='1'){ return 1;} if(x=='2'){ return 2;} if(x=='3'){ return 3;} if(x=='4'){ return 4;} if(x=='5'){ return 5;} if(x=='6'){ return 6;} if(x=='7'){ return 7;} if(x=='8'){ return 8;} if(x=='9'){ return 9;} if(x=='A'||x=='a'){ return 10;} if(x=='B'||x=='b'){ return 11;} if(x=='C'||x=='c'){ return 12;} if(x=='D'||x=='d'){ return 13;} if(x=='E'||x=='e'){ return 14;} if(x=='F'||x=='f'){ return 15;} return -1; } char hexch(int x) { if(x== 0){ return '0';} if(x== 1){ return '1';} if(x== 2){ return '2';} if(x== 3){ return '3';} if(x== 4){ return '4';} if(x== 5){ return '5';} if(x== 6){ return '6';} if(x== 7){ return '7';} if(x== 8){ return '8';} if(x== 9){ return '9';} if(x==10){ return 'A';} if(x==11){ return 'B';} if(x==12){ return 'C';} if(x==13){ return 'D';} if(x==14){ return 'E';} if(x==15){ return 'F';} return '\0'; } char *dec(int a, int b) { return matriz[a][b]; } int urlDecode(char *out, char *s ) { int a, b; int tm = strlen(s); int remove=0; char c, decoded[8]; strcpy(out, ""); //limpa tudo que tiver em out for(int i=0; i<tm; i++) { c = *s++; if (c=='%') { a = hex(*s++) ;// primeiro hexadecimal b = hex(*s++) ;// segundo hexadecimal strcpy(decoded, ""); strcat(decoded, dec(a,b)); strcat(out, decoded); //nem todos são formados por um //unico caractere. Remove ecesso no final remove+=strlen(decoded); } else if (c == '+') { strcat(out, " "); } else { char m[2]={c,'\0'}; strcat(out, m); } } out[strlen(out)-remove]='\0'; return strlen(out); } void matrixDecode() { printf( "\nMatriz de decodificação:\n"); for(int i=0; i<16; i++) { for(int j=0; j<16; j++) { printf("%c%c=%s\t", hexch(i),hexch(j),dec(i,j)); } printf("\n"); for(int j=0; j<16; j++) { printf("%i=%s\t", i*16+j,dec(i,j)); } printf("\n"); printf("\n"); } } void testaDecode() { printf( "\nTestando decode:\n"); char *url = "username=%C1gatha+Silva&email=agata%40dasilva.com"; printf( "url = %s\n", url ); int tm = strlen(url); printf( "tamanho url = %i\n\n", tm); char resp[tm]; tm = urlDecode(resp, url) ; printf( "decodificado = %s\n", resp); printf( "tamanho do decod = %i\n", tm); } int main() { matrixDecode(); testaDecode(); return 0; } Esses fontes são interessantes, mas não funcionaram pra mim: https://www.rosettacode.org/wiki/URL_encoding https://www.rosettacode.org/wiki/URL_decoding Se esse programa rodar no servidor, quem poderia me mostrar um exemplo de encode que poderia fazer algo inesperado com o sistema?

Isso é só pra demonstrar que o tamanho na declaração do array não deveria ser importante para a função que recebe o parametro: #include <stdio.h> #include <stdlib.h> #include <stdbool.h> typedef struct { char nome[50]; int idade; } pessoa; int s1(pessoa pessoas[]) { printf("----------------------------------\n"); int i=0; for(; pessoas[i].idade!=NULL; i++) { //printf("Nome: %s Idade:%i\n", pessoas[i].nome, pessoas[i].idade); } printf("Tamanho: %i \n", i); return 0; } int main() { pessoa pessoas1[] = {{"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}, {NULL, NULL}}; s1(pessoas1); pessoa pessoas2[] = {{"Maria", 70}, {"Gabriel", 15}, {"Samuel", 11}, {"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}, {NULL, NULL}}; s1(pessoas2); return 0; } E funciona. Só que é feio porque sou obrigado a fazer um while... de alguma forma outras linguagens fazem isso de forma invisivel. E é feito porque tenho que utilizar um marcador com a struct com NULLs...

Eu não te pedi nada além de coerencia. E lhe agradeci muito pelo pelo navegador que postou. Mas isso não lhe dá direito nenhum de falar assim com ninguem. Era essa sim. E eu ainda repeti em #5. Mas a pergunta é tão compreensivel que logo no primeiro post que fiz o usuário Flavio Pedroza entendeu e respondeu rapidamente eu eu já lhe dei like e o atribui como o solucionador do problema. Por isso que quero saber se você é uma inteligencia artificial. porque por ética, você, como robo do forum é obrigado a dizer se é ou não. deixa eu te explicar o que aconteceu... você veio e disse que tinha uma forma de fazer. fez um post gigante #8 e eu para não te deixar no vácuo, postei um link de um post meu #9, que é mais antigo a esses seus posts pra te dar uma dica que desse modo eu sabia como pegar o tamanho de arrays. Eu tava tentando ser gente boa contigo, pra não te deixar no vácuo porque tava sendo legal ao mostrar seu navegador, que eu já lhe agradeci. Ok. Mas eu não to aqui pra usar ctrl+c + ctrl+v. Eu to aqui para entender e criar meus proprios metodos. No link que eu passei, mostra que eu já fiz o equivalente. porque eu iria fazer um post como esse? ok... sua suposição foi boa porque foi além do esperado. Mas não tente advinhar o que um usuário quer fazer a partir de uma pergunta simples. ok! Desculpa. falou sim. Mas o porque não funciona, eu não vi, ou não entendi. Se se refere ao que disse que o compilador não sabe o tamanho do registro que irá receber como parametro, isso não é uma resposta que explica o porque.

Sim! É isso mesmo. Valeu pelas dicas!

Moço, acho que já te falei isso... uma hora você fala uma coisa e logo depois fala o contrário ou diz que não entendeu... Olha o que escreveu no mesmo post: Quem determinou isso? Desde sempre o que? Não é assim que funciona o que? Sim. Os exemplos são simples. Mas o problema é mais simples ainda... veja: você tem um array e passa apenas ele para uma função que deve imprimir a quantidade de pessoas do array: pessoa pessoas[] = {{"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}}; escrever_arquivo(pessoas); // deve imprimir a quantidade de elementos do array pessoas // escrever_arquivo(pessoas, tm);// não achei elegante esse método. Agora olha as funções que criou: Em Grupo1* cria_grp1(unsigned init, unsigned incr) você fez Grupo1* G = (Grupo1*)malloc(sizeof(Grupo1)); E em que Lugar dá free nisso? em Grupo1* apaga_grp1(Grupo1* g) tem free(g); Em Grupo2* cria_grp2(unsigned init, unsigned incr) você fez Grupo2* G = (Grupo2*)malloc(sizeof(Grupo2)); E em que Lugar dá free nisso? em Grupo2* apaga_grp2(Grupo2* g) tem free(g); Em Grupo3* cria_grp3(unsigned init, unsigned incr) você fez Grupo3* G = (Grupo3*)malloc(sizeof(Grupo3)); E em que Lugar dá free nisso? Mas... Em Grupo3* apaga_grp3(Grupo3* g) você não fez free(g) nessa função. Ou seja... você não pode ser uma inteligencia artificial por isso. Mas deixa duvidas que seja. você é uma inteligencia artificial? pra mim está claro que apagou todo o grupo. Ou seja, você criou uma função que apaga todo o grupo de uma vez e não uma pessoa de cada vez. Então dizer que você não apagou é um absurdo semantico, pois você delegou isso à função (escolha sua). você não vai com lapis escrever e borracha apagar do HD ou da memória. Não quero dizer que seu codigo está errado, ate porque mesmo dentro dessas funções demonstram o conhecimento o suficiente para qualquer um fazer sua propria função apaga_pessoa e cada um pode fazer a mesma coisa de formas diferentes. Eu não entendi porque você deu uma resposta tão grande para uma pergunta tão simples. Os grupos normalmente (dependedo do contexto, é claro) existem na forma de struct (sem precisar de malloc), mesmo que vazios de pessoas. Mas as pessoas nem sempre existem. Podem ser inseridas, editadas, mostradas ou excuidas do grupo.

valendo quanto? Se for pra você, pra uso pessoal eu faço. Mas se for trabalho de escola eu não faço. Mas te aponto o caminho das pedras. O ultimo post do usuário ARFNETO, desse link abaixo resolve, de forma primorosa, sua questão: https://www.clubedohardware.com.br/forums/topic/1558998-por-que-não-consigo-pegar-o-tamanho-de-um-array-de-structs/

Pelo que andei lendo, é posivel sim. Mas exige certos procedimentos que me parecem ser complexos de mais. Algo arriscado e que não compensa. Pelo que imagino o que devo fazer se tiver várias threads necessitando de algo assim, eu tenho que colocar cada pedido de leitura e/ou gravação em um tipo de pilha que irá sendo executada na sequencia, atendendo cada thread uma por uma.

É possivel usando threads que um mesmo arquivo possa ser aberto ao mesmo tempo por dois fopens? Um fopen para leitura e outro fopen para escrita?

Muito legal. Para a minhas necessidades eu só precisava de 9.999 registros! Tá bom de mais da conta! Eu fiz um exemplo desses utilizando array dinamicos (maloc), mas pensei que tinha forma mais simples do que a que fiz. Ficou um pouco parecido com a struct Grupo: https://www.clubedohardware.com.br/forums/topic/1558865-alocação-dinamica-de-array-inclusão-exclusão-e-free/ Agora aqui, busquei uma forma sem uso de strutc, querendo pegar o tamanho do array sem precisar passar parametros além do array ou ficar utilizando contadores, como na struct grupo dos seus exemplos ou do Array do link acima que passei. Vejo que não é tão simples como pensei que fosse, pois achava que existia uma forma de pegar o tanhado do array ja dentro da função sem uso de struct e contadores. Bem... pelo menos eu não consigo fazer. Acredito que especifiquei errado o problema. De qualuqer forma, obrigado. Gostei de muita coisa que postou aqui. voltando ao seu post... Sim. Percebi isso na função int deleteByIndexInArray(Array *a, int item) , do exemplo do link que passei. Realmente isso não é legal porque fica fazendo copias. Feio... Mas o que você fez de diferente? Não entendi. você simplesmente apagou todo o grupo. E não apenas ou uma sequencia de pessoas quais queres. Para evitar tanta movimentação, acredito que a função void insertInArray(Array *a, myData element) multiplique o tamanho por 2 sempre que atinge o tamanho limite. Isso eu tinha achado interessante. E nos seus insere, em todos, você utiliza realloc. A diferença, que eu gostei bastante, é que você permite o tamanho do incremento passado por parametro. Achei mais bonito. Mais elegante. pra eu passar a régua, sem ficar copiando e apagando sempre que alterar um registro, eu teria que usar uma lista. Ou seja, uma estrutura em que existe um ponteiro apontando para o dado anterior e outro ponteiro apontando para o dado posterior. É bem legal, bonito e interessante. Sim. Entendo isso como metadados. Eles melhoram a eficiencia das operações com os dados. Exemplo os ponteiros que apontam para o elemento anterior e posterior ao elemento "selecionado". Não entendi porque você fez isso nos grupos cria_grp1, cria_grp2 e cria_grp3: Grupo1* G = (Grupo1*)malloc(sizeof(Grupo1)); Grupo2* G = (Grupo2*)malloc(sizeof(Grupo2)); Grupo3* G = (Grupo3*)malloc(sizeof(Grupo3)); No meu entendimento o equivalente disso é a struct Array que fiz fiz em: https://www.clubedohardware.com.br/forums/topic/1558865-alocação-dinamica-de-array-inclusão-exclusão-e-free/ porque fez isso, algo que necessitaria de um free depois que terminasse de utilizar? Não sei se daria certo para mim na maioria dos meus casos, pois geralmente quando gravo dados sobre pessoas, se eu for apagar, eu apago um de cada vez. Não apago todo o grupo de pessoas (array) de uma vez. No meu entendimento, talvez tenha sido por isso que fez dessa maneira, pois não havendo necessidade de apagar o grupo e sim uma pessoa de cada vez, não precisaria fazer um maloc de cada grupo, como foi feita na sua sugestão. Em resumo: não estou certo do porque fez o maloc de cada grupo, mas entendo porque fez de cada pessoa. Não entendi o que quis dizer com isso. O que quer dizer processos intermediários? O que entendi é que o NULL serve como um marcador. Mas em que isso torna melhor que os outros dois primeiros modos? Quando isso será mais util que os dois primeiros? //Ok! Mas como eu faço para que a função que recebe o seguinte array como parametro pegar o tamanho dele? pessoa pessoas[] = {{"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}}; // usando uma função simples assim: escrever_arquivo(pessoas); Amei sua função int testa_arquivo(const char* arquivo). O navegador para o arquivo "binário". Lindo isso! Cara, valeu! Mesmo! De mais da conta!

Acho que o terceiro fonte desse post é o exemplo perfeito do meu erro: https://www.techiedelight.com/find-size-of-an-array-c/ E o quarto fonte parece ser a solução, mas não funcionou pra mim passando por parametro.

Pessoa gente[20]; printf("Tamanho do vetor: %zd\n", sizeof(gente) / sizeof(gente[0])); return 0; Isso eu sei. Mas como fazer isso sem ser obrigado a passar por parametro o tamanho. Nem sempre se sabe o tamanho antes de se chamar a função. E é nisso que mora a beleza da coisa. Quando o array é populado de forma dinamica. Mas acredito que essa seja a solução: Então eu uso o tamanho da struct do array (no caso pessoa), e vou retirando, a partir do endereço de pessoas até encontrar \0. vou testar isso. Obrigado

como não pretendo usar banco de dados para um projetinho aqui, acho que vou fazer isso mesmo. mas me incomoda não conseguir encontrar uma forma de recuperar dados corrompidos nesses DATs. imagino que seria melhor eu salvar nos dois formatos. O DAT para ter a eficiencia e o XML para garantia.

E eu que tenho que tocar um pandeiro pra torneira do meu banheiro funcionar... o povo faz as casas hoje parecerem uma dimensão paralela.

Muito obrigado! Achei isso estranho. Estou acostumado com java. por isso achei isso feio... Parece (estou certo?) que eu só devo utilizar ponteiros na passagem de parametros se eu tiver criado ele com maloc. De outro modo, a passagem de ponteiros é desnecessário, sendo melhor trabalhar com o array. Veja que consegui fazer usando arrays acrescentando mais um parametro, como sugeriu: #include <stdio.h> #include <stdlib.h> #define MAX 100 typedef struct { char nome[50]; int idade; } pessoa; int escrever_arquivo(pessoa pessoas[], int tm) { FILE * arq; arq = fopen("dados.bin", "ab"); if(arq == NULL) { printf("\nErro ao abrir o arquivo para leitura!\n"); fclose(arq); return -1; } for(int i=0; i<tm; i++) { fwrite(&pessoas[i], sizeof(pessoa), 1, arq); } fclose(arq); return 0; } int ler_arquivo(pessoa aux_pessoas[]) { FILE * arq = fopen("dados.bin", "rb"); if(arq == NULL) { printf("\nErro ao abrir o arquivo para leitura!\n"); return -1; } int indice = 0; pessoa p; while(fread(&p, sizeof(pessoa), 1, arq)) { aux_pessoas[indice++] = p; } fclose(arq); return indice; } int main(int argc) { char oper; int len_vet; pessoa aux_pessoas[MAX]; while (oper != 's') { printf("================ MENU ================ \n"); printf("Escolha: \ng - Para gravar\nl - para ler\ns - para sair\n"); scanf(" %c", &oper); switch (oper) { case 'g':; pessoa pessoas[] = {{"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}, {"claudia", 55}}; // Sei que é 4, mas aqui pego o tamanho de forma dinamica: int tm = sizeof(pessoas)/sizeof(pessoa); // É estranho que a função consiga ler todo o conteudo, mas não sabe onde ele termina // mesmo trabalhando com ponteiro, fazendo algo assim: // pessoa *p = pessoas; // e passando por parametro o p, sou obrigado a passar tm por parametro. Ou seja, // não faz diferença fazer isso e por simplicidade é melhor deixar como está. escrever_arquivo(pessoas, tm); break; case 'l': len_vet = ler_arquivo(aux_pessoas); if(len_vet>0) { printf("=========================================\n"); for(int i=0; i<len_vet; i++) { printf("Nome: %s\n", aux_pessoas[i].nome); printf("Idade: %d\n", aux_pessoas[i].idade); printf("-----------------------------------------\n"); } } break; case 's': break; default: printf("opcao invalida!\n"); break; } } return 0; }

Gostaria de pegar o tamanho do array, mas não sei porque estou errando: #include <stdio.h> #include <stdlib.h> #define MAX 100 typedef struct { char nome[50]; int idade; } pessoa; int escrever_arquivo(pessoa pessoas[]) { FILE * arq; arq = fopen("dados.bin", "ab"); //to apanhando aqui e tentei várias coisas sem sucesso: int len_vet = sizeof(pessoas); //int len_vet = sizeof(pessoas)/sizeof(pessoas[0]); //int len_vet = sizeof(pessoas)/sizeof(pessoa); printf("tamanho deveria ser 3, mas é = %i\n", len_vet); printf("tamanho do tipo = %i, tá errado esse tamanho!\n", sizeof(pessoa)); printf("tamanho do pessoas[0] = %i, tá errado esse tamanho!\n", sizeof(pessoas[0])); if(arq == NULL) { printf("\nErro ao abrir o arquivo para leitura!\n"); fclose(arq); return -1; } for(int i=0; i<len_vet; i++) { fwrite(&pessoas[i], sizeof(pessoa), 1, arq); } fclose(arq); return 0; } int ler_arquivo(pessoa aux_pessoas[]) { FILE * arq = fopen("dados.bin", "rb"); if(arq == NULL) { printf("\nErro ao abrir o arquivo para leitura!\n"); return -1; } int indice = 0; pessoa p; while(fread(&p, sizeof(pessoa), 1, arq)) { aux_pessoas[indice++] = p; } fclose(arq); return indice; } int main(int argc, char *argv[]) { char oper; int len_vet; pessoa aux_pessoas[MAX]; while (oper != 's') { printf("================ MENU ================ \n"); printf("Escolha: \ng - Para gravar\nl - para ler\ns - para sair\n"); scanf(" %c", &oper); switch (oper) { case 'g': ; pessoa pessoas[] = {{"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}}; escrever_arquivo(pessoas); break; case 'l': len_vet = ler_arquivo(aux_pessoas); if(len_vet>0) { printf("=========================================\n"); for(int i=0; i<len_vet; i++) { printf("Nome: %s\n", aux_pessoas[i].nome); printf("Idade: %d\n", aux_pessoas[i].idade); printf("-----------------------------------------\n"); } } break; case 's': break; default: printf("opcao invalida!\n"); break; } } return 0; } porque sempre tenho que adicionar ';' dentro do primeiro case? case 'g': ; // <- aqui! pessoa pessoas[] = {{"Luiz", 44}, {"Sofia", 11}, {"Daniele", 35}};

Ok! Entendo. Mas como recuperar os dados, ou pelo menos parte deles se acontecer de o arquivo tiver com defeito? Como eu disse, apesar de o TXT não ter uma boa performance em comparação com DAT, parece ser o modo mais seguro de se salvar os dados.

Olá pessoal! Eu tenho um CD velho, arranhado, mas que ainda é possivel visualizar os arquivos dentro. Alguns estão corrompidos, outros não, como TXTs. Os Txts aparecem com alguns erros, mas ainda é possivel interpretar o conteudo e corrigir os erros. A questão é que se eu tivesse salvo os dados usando array de structs em C, provavelmente não conseguiria abrir eles novamente utilizando o mesmo programa. Mesmo hoje, se eu tiver salvado um arquivo dat, e alterar com qualuqer programa alguns poucos bytes, o programa não conseguirá interpreta-lo novamente. Irá dar erro nos dados. Arquivo corrompido... Assim, me parece mais lógico salvar os dados em TXT onde cada celula fosse separada por \t ou pipe '|' e linha por \n. Então, quais as vantagens e desvantagens de utilizar DAT e TXT? pra que obrigação de inserir codigo? Algum post meu tá vagando por ai porque não adicionei um codigo fonte?

Eu encontrei um post bem legal mostrando como fazer alocacao dinamica de arrays e quis compartilhar minha adaptação. Eu achei interessante o insertInArray porque ele só faz o tamanho do array dobrar quando a quantidade usada ating e a quantidade limite. Mas na deleção ele corrige para o tamanho em uso. Será que isso é uma boa ideia ou não vale a pena reduzir o tamanho depois da remoção de algum item? // fonte da ideia: // https://stackoverflow.com/questions/3536153/c-dynamically-growing-array/3536261 #include <stdio.h> #include <stdlib.h> typedef struct { int index; char *name; } myData; typedef struct { myData *array; size_t used; size_t size; } Array; void initArray(Array *a) { myData *pointer; pointer = (myData *)malloc(sizeof(myData)); if (pointer == NULL) { printf("Unable to allocate memory, exiting.\n"); free(pointer); exit(0); } else { a->array = pointer; a->size = 0; a->used = 0; } } void insertInArray(Array *a, myData element) { // a->used é o numero usado // a->size é o limite if (a->used == a->size) { if(a->size==0)a->size=1; else a->size *= 2; a->array = realloc(a->array, a->size * sizeof(myData)); } a->array[a->used++] = element; } int deleteByIndexInArray(Array *a, int item) { Array temp; myData *pointer; initArray(&temp); for(int i=item; i<a->used; i++) { a->array[i] = a->array[i + 1]; } a->used -= 1; for (int i=0; i<a->used; i++) { insertInArray(&temp, a->array[i]); } pointer = (myData *)realloc(temp.array, (temp.used) * sizeof(myData)); if (pointer == NULL) { printf("Não foi possivel realocar memoria.\n"); free(pointer); return -1; } printf("item %i deletado do array.\n", item ); a->array = pointer; return 0; } void deleteByDataInArray(Array *a, myData element) { myData data; for(int i=0; i<a->size; i++) { data = a->array[i]; if( !strcasecmp(data.name, element.name) ) { printf("%s deletado do array.\n", data.name ); deleteByIndexInArray(a, i); break; } } } void freeArray(Array *a) { free(a->array); a->array = NULL; a->used = a->size = 0; } int main() { myData d1, d2, d3, d4, d5, d6; Array pointers; initArray(&pointers); d1.index=1; d1.name="Luiz"; insertInArray(&pointers, d1); d2.index=3; d2.name="Sofia"; insertInArray(&pointers, d2); d3.index=4; d3.name="Flavia"; insertInArray(&pointers, d3); d4.index=5; d4.name="Daniele"; insertInArray(&pointers, d4); d5.index=7; d5.name="Claudia"; insertInArray(&pointers, d5); printf("======================================\n"); for (int i = 0; i < pointers.used; i++) { printf("Index: %i Name: %s\n", pointers.array[i].index, pointers.array[i].name); } printf("======================================\n"); deleteByIndexInArray(&pointers, 3); printf("======================================\n"); for (int i = 0; i < pointers.used; i++) { printf("Index: %i Name: %s\n", pointers.array[i].index, pointers.array[i].name); } printf("======================================\n"); deleteByDataInArray(&pointers, d5); printf("======================================\n"); for (int i = 0; i < pointers.used; i++) { printf("Index: %i Name: %s\n", pointers.array[i].index, pointers.array[i].name); } freeArray(&pointers); return (EXIT_SUCCESS); } Certamente deve ter alguém com exemplos mais legais.

A dica é que você primeiro deve saber: 1) conhecer e saber como declarar os tipos de dados em C; 2) conhecer e saber como são realizadas as operações matemáticas em C; 3) o que é e como são construidas matrizes (Array) em C; 4) como se fazer funções, passando parametros e recebendo valores e C, sejam eles dos tipos basicos conhecidos assim como utilizando ponteiros. Ou seja... 5) É interessante também saber o que são ponteiros e como trabalhar com eles; 6) Saber como capturar dados a partir do teclado em C. Exemplo como scanf, gets, getchar, getch... 7) como imprimir resultados utilizando a função printf, puts.

tenta isso: using System; using kk; namespace kk { public class Msn { public void mensagem() { System.Console.WriteLine("Olá mundo!"); } } } public class Jogo { static void Main(string[] args) { Msn n1 = new Msn(); n1.mensagem(); Console.ReadKey(); } } //no exemplo encontrado abaixo mostra como pode fazer isso: //https://www.tutorialspoint.com/csharp/csharp_namespaces.htm //Olha essa parte quando um namespace tá dentro do outro como fica: //using System; //using first_space; //using first_space.second_space;

É sim, por isso gosto de foruns como esse. Entendi foi PN de nada. Obrigado! vou ler agora mesmo. Não vi que tinha coisa pra ler já aqui. Que legal, não é? Realmente isso é um dos macetes da linguagem. Obrigado. Like pra você. Legal! funcionou: #include <stdio.h> #include <stdlib.h> #include <string.h> char *inverte(char *str) { int tm = strlen(str); char temp; for(int i=tm/2; i>=0; i--) { temp = str[i]; str[i] = str[tm-i-1]; str[tm-i-1] = temp; } return str; } int main(void) { char nome[] = "abcdefghijklm"; char *n = nome; n = inverte(n); printf("%s\n", n); return 0; } Parece ser mais uma particularidade da linguagem... Quem pensa de forma algoritmica, (pra qualquer linguagem ou o portugol), é quem deveria se sentir responsavel por tomar essa decisão de dizer se quer ou não alterar a string. de qualquer forma, obrigado por dipor conhecimento. Se a strrev morreu por isso, a culpa não é dos usuários?

A seriedade de uma faculfade está na capacidade de montar banca examinadora. E essa faculdade tem. Eu já estudei em um monte de lugar, foi a que melhor apresentou conhecimento e preparo. Eu agradeço aos outros apontamentos (VB, como as subs e etc) são realmente instrutivos. Quanto ao ensino para iniciantes, acho excelente o inicio da diferenciação de método e função ser como a apresentada, conforme o senhor mesmo disse "Dijkstra ?", pois é a primeira coisa que o aprendiz ve. Ele não vai relacionar de imadiato muita coisa. Nem eu me importo com isso e nem vou me importar porque pra mim o que importa é entender as expressões da linguagem. E para o caso, como tudo antes faço do portugol, a forma de representar a chamada de metodos que conheço em c é mais ou menos assim: var = function(com parametro ou sem parametro); // variavel recebe valor como resultado da chamada de uma função ou simplesmente function(com parametro ou sem parametro); // Não tem variavel. É apenas o método sendo executado. É, para iniciantes do portugol, chamada de método. É a partir disso que você elabora soluções para cada linguagem. Novamente agradeço ao conteudo instrutivo.

Então eu suponho que essa forma é a de melhor performance, poide deve ser bem mais rápida. eu to tentando fazer isso, mas acho que estou fazendo isso errado... Olha só: #include <stdio.h> #include <stdlib.h> #include <string.h> char *inverte(char *str) { int tm = strlen(str); // agora dá pra fazer swap? char temp; for(int i=tm/2; i>=0; i--) { temp = str[i]; str[i] = str[tm-i-1]; str[tm-i-1] = temp; } // Pô! Num deu! return str; } int main(void) { char *nome = "abcdefghijklm"; nome = inverte(nome); printf("%s\n", nome); return 0; } Aqui pra mim aparece falha na seguimentação. Imagem do núcleo gravada. Não sei em que uma mensagem assim ajuda... Bem legal! Mas não consigo fazer algo equivalente funcionar aqui quando o parametro de entrada é char*. Eu acho difícil ser uma questão de diferença de compilador. Eu acho que to errando mesmo.