Ir ao conteúdo
  • Cadastre-se

isrnick

Membros Plenos
  • Total de itens

    1.367
  • Registro em

  • Última visita

  • Qualificações

    0%

Reputação

1.269

7 Seguidores

Informações gerais

  • Cidade e Estado
    Sao Paulo
  • Sexo
    Masculino
  1. Ao fazer pc++ você altera pc, mas então você tenta realocar usando essa posição incrementada ao fazer realloc(pc, qte*sizeof(t_carro)); , o que vai dar erro pois pc não aponta mais para a posição original da memória que foi alocada com malloc.
  2. Mude: realloc(pc, qte*sizeof(t_carro)); Para: pc = realloc(pc, qte*sizeof(t_carro)); E não incremente nele... pc++; Acesse usando índices: pc[qte-1]->modelo
  3. https://www.clubedohardware.com.br/forums/topic/1403199-erro-no-código-ponteiro-para-a-estrutura-de-dados-heterogênea/
  4. scanf("%s", &nome[linha]); Não vai & antes do nome do vetor ou matriz nos scanfs, pois o nome já é um endereço de memória. Então corrigindo a linha acima ficaria: scanf("%s", nome[linha]);
  5. Usar system() é uma má ideia por muitos motivos, as pessoas aprendem a fazer assim por ser fácil, e pode até ser útil quando precisa de algo para uso próprio que possa ser feito rápido mas será descartado depois, mas não é uma solução viável para qualquer coisa mais que isso. sendfile e copyfile realmente podem ser mais rápidos, mas não são portáveis, mas são boas opções se vai programar para seus respectivos SO, ou então se vai usar #ifdef _WIN32 #else #endif elas seriam melhores opções do que usar system(). open, read e write são funções POSIX e também são opções mais rápidas por não usarem buffer, e também podem ser boas opções, mas a Microsoft as considera funções descontinuadas substituindo-os por _open, _read e _write: https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/open?view=vs-2019 https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/posix-read?view=vs-2019 https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/posix-write?view=vs-2019 fopen, fread e fwrite apesar de não serem tão rápidas por usarem buffer, são funções da biblioteca padrão da linguagem C logo são a melhor opção para programar algo que provavelmente funcionará em qualquer situação. Portanto considero que uma solução usando fopen, fread e fwrite seria a solução padrão, e as outras seriam opções extras que podem ser mais adequadas dependo da necessidade ou situação.
  6. Está errando na interpretação do que o enunciado pede para fazer. É para criar um ponteiro que aponta para estruturas do tipo struct registro: struct registro *ponteiro; E fazê-lo apontar para a variável cadastro (que é um struct registro): ponteiro = &cadastro; E agora ao invés de acessar os dados da struct diretamente pela variável cadastro (ex: cadastro.Ru) irá acessar os dados através do ponteiro (Ex: ponteiro->Ru).
  7. char *nome; typedef struct dados_do_aluno aluno;
  8. Como o erro indicou scanf_s não foi declarado neste escopo, mude os scanf_s para scanf...
  9. Leia as mensagens de erro elas normalmente indicam bem o problema... Ou seja, na linha 8 foi apontado que é esperado um ; no fim da declaração de um membro da struct, então note que na linha 7 você não colocou ; depois de "char *nome"... Na linha 12 typedef foi ignorado e na linha 13 diz que o tipo 'aluno' não foi declarado nesse escopo, logo o problema é que você não definiu o tipo aluno, ou seja na linha do typedef você queria definir struct dados_do_aluno como um tipo de nome aluno, mas esqueceu de colocar o nome do tipo.
  10. Qual seria o convencional? Eu achava que esse é o método convencional...
  11. Pensei sim. Você está apontando coisas que estão fora do escopo de controle da função replace() proposta para o exercício, do modo como ela foi proposta a função não tem como checar a validade dos parâmetros passados para a função, logo deve assumir que eles são adequados para que ela possa realizar seu trabalho. Várias funções da biblioteca padrão tem a mesma limitação, como scanf, strcat, sprintf, etc, e a responsabilidade fica a cargo do programador de garantir que os requisitos sejam atendidos ao chamar a função. A proposta da biblioteca padrão para minimizar o problema foi criar funções "seguras" (com _s no final do nome) onde é adicionado um parâmetro a mais na função para indicar um limite máximo de caracteres, normalmente usado para indicar o tamanho do vetor de caracteres, para que este não seja excedido. Mas no caso aqui do tópico o enunciado do exercício especifica o protótipo da função replace(), e para fazer uma versão mais "segura" seria necessário modificá-lo. Isto é um problema da linguagem C em geral, que é muito insegura, logo deve-se tomar cuidados especiais ao programar, mas nesse caso até poderia ativar warnings de compilação para quando usar um tipo incompatível ao chamar a função (como no caso de passar uma constante nesta função). Entretanto o problema que apontei trata-se de outra coisa, é algo controlado pela própria função, e seria algo invisível para alguém que não programou a função (se ela fizesse parte de uma biblioteca por exemplo), e não saberia da limitação de tamanho do vetor auxiliar usado dentro da função, então a pessoa poderia passar todos os parâmetros adequadamente e mesmo assim a função produziria algo errado, e o programador ficaria sem entender por que... Resolve o problema que apontei, você indicou outra coisa. Qual seria a vantagem de preservar o texto no vetor original até formar o texto alterado no vetor auxiliar nesse caso? A função replace() só tem a opção de não fazer nenhuma alteração (caso index seja inválido ou o texto seja uma string vazia logo não há nada para substituir), ou então deve alterar o texto original. Não há hipótese em que ele começa a fazer a alteração mas algo impede que finalize, e seja necessário cancelar a alteração, esta seria a situação onde seu argumento realmente seria um requisito para a função, mas não é o caso aqui. Como falei até seria possível evitar erros usando alocação dinâmica de memória para criar o vetor auxiliar, mas não vejo nenhuma desvantagem de não usar um vetor auxiliar nesse caso, e até tem a vantagem de economizar memória. Onde a biblioteca padrão do C faz isso? Pelo contrário, em geral em funções destrutivas/construtivas ela retorna um endereço de memória que aponta para um vetor normal que foi passado como parâmetro de entrada da função (A função strtok() até retorna endereços apontando para várias posições diferentes do mesmo vetor de entrada cada vez que ela é chamada, e também altera o texto do vetor diretamente destruindo o texto original). O conceito de aprender a pensar como programador que eu quis passar é o de programar código que sirva não apenas para atender o problema proposto, mas também sirva para outras situações que vão além das situações do problema proposto, podendo reutilizar o código para outras situações sem precisar fazer adaptações, e também de fazer o possível para eliminar ou minimizar ao máximo as possibilidades de erros que podem ocorrer ao executar o código em diferentes situações.
  12. @arfneto Sim, usar um vetor auxiliar facilita um pouco em programar uma solução, mas o problema do vetor auxiliar é que ele pode não ser grande o suficiente se o texto for muito longo, o que causaria sérios erros no resultado final, então para evitar erros ou seria necessário reservar uma quantidade exagerada de espaço para o vetor auxiliar, o que minimizaria a chance de erro mas não a eliminaria, ou precisaria usar alocação dinâmica (malloc) para reservar a quantidade exata conforme necessário dependendo do tamanho do texto, o que resolveria o problema ao custo de aumentar a complexidade da solução. Mas eliminando a necessidade do vetor auxiliar não apenas resolve este problema, como também economiza memória. Claro isso não é algo que um iniciante já tenha que considerar enquanto ainda está começando a aprender a programa, mas acho importante apontar onde os problemas podem ocorrer e onde o código pode ser melhorado, para aprender a pensar como um programador pois esse é o tipo de coisa que eventualmente vão ter que fazer. A função sem usar vetor auxiliar poderia ficar assim: void replace(char *texto, int index, const char *tag){ int i; size_t lentexto, lentag; lentexto = strlen(texto); if (lentexto == 0 || lentexto <= index) { return; } lentag = strlen(tag); if(lentag != 0){ //Move tudo depois do index lentag-1 casas para frente para abrir espaço: for(i = lentexto; i > index; i--){ texto[i+lentag-1] = texto[i]; } //Preenche o espaço com a tag: for(i = 0; i < lentag; i++){ texto[index+i] = tag[i]; } } else { //se a tag for uma string vazia //Move tudo depois do index uma casa para trás: for(i = index; i < lentexto; i++){ texto[i] = texto[i+1]; } } }
  13. @vangodp Também precisa guardar quais foram os atletas com maior e menor notas. Eu sugiro passos um pouco diferentes: declarar n, maior, atletamaior, menor, atletamenor ler nota do primeiro atleta e atribuir a n maior é a nota do primeiro atleta, menor nota é a nota do primeiro atleta, o primeiro atleta é o atletamaior e o atletamenor >> Repete 14 vezes -ler nota e atribuir a n -comparar n com "maior", se n for maior que a variável "maior", atribuir n a maior e o número do atleta ao atletamaior -comparar n com "menor", se n for menor que a variável "menor", atribuir n a "menor" e o número do atleta ao atletamenor <<
  14. Esse é um exercício de ciclos (while, for, ou do while) e deve usar um ciclo para resolver. A ideia básica é fazer um ciclo que repete várias vezes a pergunta pedindo a nota do n-ésimo atleta, dentro do ciclo deve guardar em uma variável a maior nota, e em outra variável no número do atleta com a maior nota, e também a menor nota, e em outra variável o número do atleta com a menor nota. Note que isso é um exercício de máximo e mínimo, o que significa que inicialmente pode simplesmente admitir que o primeiro valor do primeiro atleta é tanto a maior quanto a menor nota de todos os atletas, e a partir do segundo atleta basta comparar com os valores guardados atualmente como maior ou menor, e então substituir se aparecer um novo valor maior que o maior atual (ou um valor menor que o menor atual).
  15. Se for fazer sem usar funções da biblioteca padrão dá pra fazer sem usar um vetor auxiliar para copiar o texto, faz as alterações diretamente dentro do vetor do texto original. Pra isso basta mover tudo que vem depois do index para a frente, abrindo espaço suficiente para escrever a tag na posição correta, para mover os caracteres para a frente deve copiar os caracteres no sentido do fim para o começo da string, começando a partir de uma posição strlen(tag)-1 além do fim da string.

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Aprenda_a_Ler_Resistores_e_Capacitores-capa-3d-newsletter.jpg

ebook grátis "Aprenda a ler resistores e capacitores", de Gabriel Torres

GRÁTIS! BAIXE AGORA MESMO!