Ansi C

@IzeraXD

Isso! O método do critério divisibilidade de 3 tem também no chamado "prova dos noves", mod (9).

O resto da divisão inteira de número decimal maior que 9 por 9 é também o resultado da adição dos dígitos mod (9) desse número.

Exemplo

Uso “loop” while 

#include"stdio.h"
int
main (void) {
  printf ("NOVE FORA\n\n");
  printf ("Digite n. inteiro decimal (>9) e direi o mod (9) dessa variavel: ");

  int a = 0;
  scanf (" %d", &a);

  int b = a;
  #define mod (9)
  while (mod <= b)
        b -= mod;
  
  printf ("resposta: %d\n", b);
  return 0;
}

Algo que certamente com uso do operador  'modulus' (%) resulta um código 'enxuto' (acima sugerido) tanto para 3 quanto para 2.

[] 

@immoraesz Isole o problema e foca nele..., somente nele!

Em 05/02/2022 às 18:00, immoraesz disse:

o programa não está retornando nenhum dos printf e não sei o motivo.

Apenas digamos que todo programa funciona, exceto os testes com as 'printf'...

Exemplo

— Escrevo outro código, mas dessa vez; excluo as informações/rotinas que antecedem o ninho de IFs com 'printf' onde supos ter um problema.

E para fim de teste, forneço o produto/ a informação que teríamos nessa etapa do programa já que omito (TáhOquei!!) nas etapas anteriores.

C language /> _

//teste do fragmento de cdh@immoraesz
#include"stdio.h"
#define N 4
typedef struct {
        char nome[50];
        char local[50];
        int valor;
} ingresso;
int
main (void) {
  ingresso
  a1 = { "a1","1", 1.0 },
  a2 = { "a2","2", 2.0 },
  a3 = { "a3","3", 3.0 },
  a4 = { "a4","4", 4.0 };

  double valor1 = a1.valor;
  double valor2 = a2.valor;
  double valor3 = a3.valor;
  double valor4 = a4.valor;
    
  if (valor1 < valor2  &&  valor3  &&  valor4) {
     printf("Mais Barato: %s (R$%d.00)", a1.nome, a1.valor);
  }   
  else if (valor2 < valor1  &&  valor3  &&  valor4) {
     printf("Mais Barato: %s (R$%d.00)", a2.nome, a2.valor);
  }
  else if(valor3 < valor1  &&  valor2  &&  valor4) {
     printf("Mais Barato: %s (R$%d.00)", a3.nome, a3.valor);
  }
  else if(valor4 < valor1  &&  valor2  &&  valor3) {
     printf("Mais Barato: %s (R$%d.00)", a4.nome, a4.valor);
  }

  if (valor1 > valor2  &&  valor3  &&  valor4) {
     printf("Mais Caro: %s (R$%d.00)", a1.nome, a1.valor);
  }
  else if(valor2 > valor1  &&  valor3  &&  valor4) {
     printf("Mais Caro: %s (R$%d.00)", a2.nome, a2.valor);
  }
  else if(valor3 > valor1  &&  valor2  &&  valor4) {
     printf("Mais Caro: %s (R$%d.00)", a3.nome, a3.valor);
  }
  else if(valor4 > valor1  &&  valor2  &&  valor3) {
     printf("Mais Caro: %s (R$%d.00)", a4.nome, a4.valor);
  }
  printf ("\n");
  (void) a1;
  (void) a2;
  (void) a3;
  (void) a4;
  return 0;
}

[SAÍDA]

Para aquela entrada de teste tem essa saída, porém, notou-se ser incorreta, ok? Isso ai! Sendo assim pouco importa as printfs quando há erro lógico nas expressões. Tudo bem, sem pânico, acredito que com a boa revisão de instrução IF e os operadores lógicos, você conseguirá na próxima tentativa.

Por último, essa CATARATA de IF é nada elegante, certamente algo que cavalheiros ou damas não fariam, exceto se por obrigação..., se não e o caso, advirto ser necessária uma linha para determinar o maior e outra para menor se optar no uso do operador ternário ou função.

[] — espero que ajude!

@IzeraXD isole o problema, observe os alerta na compilação.

[C]

#include"string.h"
#include"stdio.h"
int
main (void) {
  char texto4[120] = { "" };
  char texto3[120] = { "pokemon" }; // resultado pós-leitura do arquivo.
  unsigned long p;
  for (p = 0;  p < 3;  ++p) {
      strncpy (texto4[p], texto3[p], 2);
      printf ("uma letra = %s \n", &texto3[p]);
  }
  return 0;
} 

[compilador]

strncpy: (argumentos) Origem e Destinos são ponteiros.

[] 

1 hora atrás, mariaclara157 disse:

a minha ordem inversa acaba saindo com 1 digito a mais que não deveria estar ali, o que poderia ser?

 Tem-se acesso fora do limite lógico, está fora de limite mais tem capacidade.

Isole o problema, forneça a informação da função.

[c]

#include"stdio.h"
int
serie_invertida (int n, int termos[]) {
  int i;
  printf("\nOrdem inversa:"
         "\n{");
    
  for (i = n; i >= 0; i--)
      printf(" %d", termos[i]);
    
  printf("}\n");
  return 0;
}
int
main (void) {
  #define n (8)
  int termos[50] = {1, 2, 3, 
  [n - 5] = termos[0] + termos [1] + termos [2],
  [n - 4] = termos[1] + termos [2] + termos [3],
  [n - 3] = termos[2] + termos [3] + termos [4],
  [n - 2] = termos[3] + termos [4] + termos [5],
  [n - 1] = termos[4] + termos [5] + termos [6],
    
    [n] = 10000,
  };
  (void) serie_invertida (n, termos);
}

SAÍDA

n (8) é numero de termos e último n - 1 (7)

[] Isso ajudou a reparar o código

Olá!

As intensões estão claras, apesar de que tem "interpretações" falhas dos recursos da linguagem. 

Se os passos pensados forem: capturar, converter Caixa Alta, duplicar Invertidamente para em seguida, comparar cópia invertida com original e assim determinar ser palíndromo. Continue porque está certo, funcionará.

Mas, precisa de revisão na linguagem C.

#1

  //entrada de dados
  printf ("Entre com a palavra: \n");
  scanf ("\n %c", &entrada);

Perfeito com reação à printf, a scanf nem tanto: o que chamam 'formato' na scanf é um argumento que lhe especifica quais categorias de dados tem na entrada. Nesse caso, o especificador "%c" insinua 1 caractere. Porém, queremos uma palavra — segmento com máximo de caracteres entre dois espaços / sinais

A função é perfeita para captura, apenas o especificador que não, pois, ainda que lhe atribua largura ("%249c")  terá problema.

#2

  scanf ("%c", &invertida);

duplicar invertidamente é uma rotina no programa. Quando escolher o especificador ideal para capturar, notará que ele faz a scanf retornar o número de caracteres capturados, ou seja, a largura da palavra, uma informação prática já que precisamos duplicar ela invertidamente.

#3

  for (int j = (entrada[j] - 1) / 2; j > 0; j--) {
      if (j = (entrada[j]) / 2 - j - 1) {
         printf ("\nPalindroma \n");
      }
      else {
         (entrada[j] != invertida[j]);
         printf ("\nnao e palindroma \n");
         break;
      }
  }

comparar duas ‘strings’ é uma rotina de iteração com compreensão do início até fim da menor delas.

No fim de uma “strings” tem o valor nulo (0, ou literal '\0'), pense na maneira que esse dado ajudaria na expressão de controle ("continuidade") do ‘loop’.

[] 

20 horas atrás, oromotoceu disse:

por ter me ajudado você sabe um site para me poder recomendar de como criar uma estrutura com os elementos

Um site que ajuda aprender, struct? YouTube, a vantagem desse site é OUVIR explicações.

Tente a pesquisa: struct C.

[]  

@andrieli.m31 Olá!

É fácil dizer o que está certo!

#1 Parcialmente Certo.

while (peso > 0) {
        printf ("Informe seu peso \n");
        scanf ("%f", &peso);
      

        printf ("Informe sua altura \n ");
        scanf ("%f", &altura);

        altura = altura + total;

        total++;
}

Enunciado que a captura continua até seja digitado um valor negativo, o mesmo que ENQUANTO positivo.

Porém, nesse fragmento acima, ainda que o valor que inicia a variável seja positivo ha problema no 'loop'. Note que se digitarmos valor negativo segue solicitando altura, isso é errado.

— Eu, em seu lugar, tentaria de novo.

A expressão

        altura = altura + total;

é insignificante à solução do problema.

#2

5 horas atrás, andrieli.m31 disse:

O cálculo do IMC é feito pela fórmula: IMC = peso/altura^2

imc = peso / altura * peso / altura;

quase, note ser equivalente a: (peso)*peso / (altura)*altura

diferente do quociente do peso com quadrado da altura (citado no enunciado e no post acima desse): peso / (altura * altura)

#3

  if (imc > 18) {	//magreza
     totalMagreza++;
  }
  if (imc >= 18 && imc <= 25) { //normal
     totalNormal++;
  }
  if (imc > 25 && imc < 30) { //prC) obeso
     totalPreO++;
  }
  if (imc > 30) {	//obesidade
     totalObesidade++;
  }

A contagem de padrões (e os padrões) ficam preferencialmente no ‘loop’ onde após cada captura são verificados  e incrementados.

imc > 18

Predicado errado (no operador): certo conforme OMS/BVS, imc < 18 

Citação

Classificação do IMC (BVS):

----------------------------
Menor que 18,5 - Abaixo do peso
Entre 18,5 e 24,9 - Peso normal
Entre 25 e 29,9 - Sobrepeso (acima do peso desejado)
Igual ou acima de 30 - Obesidade

imc > 25 && imc < 30

Enunciado "até 30" (imc <= 30). Porém, a saúde diz até 29.9 (imc < 30).

Escreva, só dessa vez, conforme enunciado.

5 horas atrás, andrieli.m31 disse:

IMC / Classificação

--------------------------

Abaixo de 18 / Magreza

De 18 até 25 / Normal

Maior do que 25 até 30 / Pré-obeso

Acima de 30 /Obesidade

Para mim, tem conhecimento suficiente dos recursos da linguagem para resolver o problema.

[] — Eu tentaria até conseguir.

Em 22/01/2022 às 20:15, maria paiva disse:

Escreva um programa em C que permite ao usuário digitar números reais maiores que 4.88 para preencher as matrizes A16 x 16 e matriz B16 x 16.

Essa é a parcela mais 'chatinha' do exercício. Proponho que inicialmente não siga à risca, imagine ser 4x4.

Para valores do tipo 4.88 dados 'float' são suficientes, porém nada ti impede que sejam 'double', exceto se há uma discussão sobre uso de memória, pois double exige mais memória que float.

Simplifique a dimensão das matrizes quadrada através de uma constante.

Escreva a captura dos valores com ninho de ‘loops’: 1 “loop” para linhas e outro para as colunas, nesse último fica a rotina que captura o número real.

Proponho que escreva essa porção de código como se fosse um novo programa, após testado una ao programa principal.

Basicamente, declare duas matrizes, pegue seus valores e exiba-os.

Requisitos: FOR, SCANF, PRINTF, VARIÁVEIS E MATRIZES.

Conhece os requisitos? Se sim, então tem o necessário para programar.

E para testar será necessário digitar 16 números por matriz.

[] no aguardo.

@IsraelDev Olá!

Quão tão dito em postagens acima: a média de uma aluno é soma (de suas notas) DIV (número).

Em 30/01/2022 às 16:07, IsraelDev disse:

media_Aluno = (media_Aluno + soma_Notas) / 2;

 Não há nome para essa expressão: em outras circunstâncias gostaria que explicasse isso, mas aqui é perda de tempo.

Em 30/01/2022 às 16:07, IsraelDev disse:

O que não consigo fazer agora é encontrar uma lógica pra somar essas notas e calcular a média para cada aluno.

Talvez se escrevesse antes para 1 aluno e quando tudo ocorresse bem, escrevesse para muitos não tivesse dificuldade.  Basta começar do problema simples; uma média com uso de vetor de n-itens.

O X da questão é resolver o problema!

Algo bem diferente de assistir o problema sendo resolvido.

[] 

@Diovani Facco Olá!

Como já dito nos postes acima desse, 

Esse índice específico é o extremo (b) da diagonal principal da submatriz determinado por ele mesmo. Para saber a ordem dessa diagonal no tabuleiro é preciso por meio do extremo (b) determinar o outro "acima dele", seu extremo (a).

Sabe que a submatriz é quadrada, e que o outro extremo, talvez esteja na coluna 0

Como sugerido:

(a)coluna = 0

(a)linha    = (b)linha   MENOS   (b)coluna

— SE (b)coluna   MENOR_IGUAL   (b)linha

— Do contrário, "a direção" não fica para as linhas, vai para as colunas e (a)linha = 0

Sem novidade!

[] 

@Dérick Soares Ola! Insinua que está um "bebê engatinhando" nessa matéria e relaciona algumas falhas/erros que não pude detectar. É importante ter um código bonito e indentado e seguir sua regra consistentemente, nos iniciantes geralmente o fazemos, contudo, quando bate aquela "preguicinha", agente consulta o manual do IDE/compilador e usa a opção de customização e indentação rápida /ou site.

< C >

/*
 *	Clube do Hardware - CdH
 *	@Dérick Soares
 *      forums/topic/1584756-poucos-argumentos-na-chamada-da-função/
 */
#include"stdio.h"
#include"stdlib.h"
int
main() {
  
  float salbruto, salliquido, imposto, totbruto = 0, totliquido = 0, totimposto = 0;
  int contfunc = 1;
  do {
	printf("Digite o salario bruto: ");
        scanf("%f", &salbruto);

        if (salbruto > 999)
        	imposto = salbruto * 0.10;
        else if (salbruto > 1999)
		imposto = salbruto * 0.15;
        else if (salbruto > 9999)
		imposto = salbruto * 0.20;
        else if (salbruto > 99999)
            	imposto = salbruto * 0.25;
        else
		imposto = salbruto * 0.30;
	

	salliquido = salbruto - imposto;
	printf("Salario liquido: %.2f \n", salliquido);

        totbruto = totbruto + salbruto;
        totliquido = totliquido + salliquido;
        totimposto = totimposto + imposto;

        contfunc++;

  }

  printf("-------------------------------\n");
  printf("Total salario bruto : %.2f \n", totbruto);
  printf("Total salario liquido : %.2f \n", totliquido);
  printf("Total imposto : %.2f \n", totimposto);

  return 0;

}

saída de compilador:

gcc -std=c11 -fsyntax-only -Wall -Wextra -Werror -pedantic-errors -fanalyzer cdh/derick_soares.c
cdh/derick_soares.c: In function ‘main’:
cdh/derick_soares.c:40:3: error: expected ‘while’ before ‘printf’
   40 |   printf("-------------------------------\n");
      |   ^~~~~~

Foi declarado a instrução do {}  na função então é: previsto a 'while', antes da 'printf'.

Sem novidade! Aproposito para fazer disso um exercício.

Pare e pense!

[] — qual instrução e expressão resolve o erro sintático e o lógico desse código?

Qual a dificuldade?

A notação de 'array' é semelhante aquela que escrevemos e relativamente fácil de pegar, os ‘loops’ ou operadores são pouco para saber se ainda não sabe. Então, como seria essa "ajuda"?

Olá@Kaiza

Existem tantas outras condicionais em sua programação e essa é só mais uma que vai após escrever o resto.
 

Em 21/01/2022 às 21:14, Kaiza disse:

escreval("Dinheiro insuficiente. Faltam ", resto:4:2)

Bem aqui escreva a condicional para verificar a necessidade de plural, no caso se resto é maior que 1 então é plural.

@lsnkesp Olá!

Oh! São muito dígitos. Hum!

Em resumo, é o que o usuário disse acima. Implemente a operação matemática de subtração usando 'strings', sabe o que é 'strings'? Logo os membros da operação ficam em vetores de inteiros sendo tirados um a um para realizar subtração num jogo de pilhas de inteiros de maneira que o valor mais significativo ocupa uma das extremidades [a sua escolha] em todos os membros da operação. Como sabes, uma divisão inteira e de subtrações sucessivas.

Se é iniciante, então é melhor buscar exercícios menos demorados.

De fato o problema não é dos mais complicados, entretanto, para iniciantes talvez consuma horas e o custo disso é alto.

[] 

@kampa896  Fiz o teste num compilador 'online', usei a entrada

3
1 1
1 1

De fato, a programação falhou depois de 0.32s e não houve a saída esperada: 1

Seja lá o que você fez, não surtiu efeito. Mas, não desista, é um jogo.

[] 

Olá @Manuel Eusebio 

"Um Vetor Dinâmico", descobri ser o que o usuário acima disse, e outras coisas mais.

Citação

É uma estrutura de dados de lista de tamanho variável de acesso aleatório que permite que elementos sejam adicionados ou removidos. Ele é fornecido com bibliotecas padrão em muitas linguagens de programação modernas. As matrizes dinâmicas superam um limite de matrizes estáticas, que têm uma capacidade fixa que precisa ser especificada na alocação.

 

Um array dinâmico não é a mesma coisa que um array alocado dinamicamente, um array cujo tamanho é fixo quando o array é alocado, embora um array dinâmico possa usar um array de tamanho fixo como back-end.

Em resumo, é da categoria de dados abstratos e não existe no C normal, por isso é quase sempre um exercício de implementação que utiliza um vetor de alocação dinâmica, membros (e.g. capacidade e tamanho) e operações | funções especificas de vetor.

Penso que implementar esse dado abstrato à parte, após pronto incluir no programa, seja o ideal.

[] Como vai ser? 

Olá @immoraesz essa é a segunda postagem que vejo, e na mesma página, em que um usuário tem "bronca" com 'gets/fgets' por razão do NL que persiste (quando deve) na captura.

Como disseram, quase sempre captará esse caractere, logo melhor optar pela função 'scanf'.

# Exemplo:

Citação

 

Há um exercício da linguagem em que se deve lê uma palavra de (máximo) 19 caracteres(*)  via prompt e mostrar a sua primeira e última letra.

 

(*) Nota-se que a função 'fgets' nessa situação não é recomendada porque toda palavra numa 'string' com menos que 19 caractere terá NL quando é indesejado. Uma perfeita situação para usar 'scanf' sendo bem melhor que a 'fgets' + inspeção de caractere explicitamente.

C' 

/*******************************************************************************
*******************************************************************************/
#include"stdio.h" // scanf printf
int
main(void)
{
        char palavra_as_string[20] = {""}; int n = 0;
        printf("Ola tudo bem? Digite uma palavra (2-19 letras)\n"
               "que te direi sua 1st e Xnd letra ? ");
               
        scanf(" %19[^ \n]%n", palavra_as_string, &n);
        
        if (n > 1) {
                printf("\n\n");
                
                printf("Na posicao\n");
                printf(".1st tem %c\n"
                       ".Xnd tem %c\n\n", palavra_as_string[0],
                       palavra_as_string[n - 1]);
                       
                printf("Destaquei sua primeira e ultima letra\n");
                printf("%s\n", palavra_as_string);
                printf("^%*s^\n", n - 2, "");
        }
        return 0;
}

É muita coisa só para mostrar um uso da 'scanf'? Talvez, porém a intenção é mostrar um exercício da linguagem sem "murros em ponta de faca"

[] 

Olá @kampa896

Minha teoria é que as informações usadas para verificar a resposta no julgador 'online' não são todas ideias, pelo menos os 5% finais

Teste o seguinte:

Entrada

4
2 2
2 2

E espere pela seguinte saída

1

[] Hum! 

Sua saída é 1?

Em 06/01/2022 às 11:24, nagatonie disse:

L = { -2, 3, 4 , 1, 2, -1}

Em 06/01/2022 às 11:24, nagatonie disse:

maior somatorio: { 4, 1} = 5

Para k = 2, mas nosso cérebro nos diz que k pode ser 4 e o maior somatório {3, 4, 1, 2} = 10.

Vejam agora, eu sei que k começa com 2 e a "soma móvel" se desloca K's do índice.

Então, para k = 2 tem:

{-2, 3}, {3, 4}, {4, 1}, {1, 2}, {2, -1}, a maior soma, por enquanto, é de {3, 4} = 7, índice = 1

Então, para k = 3 tem:

{-2, 3, 4}, {3, 4, 1}, {4, 1, 2}, {1, 2, -1}, a maior soma, por enquanto, é de {3, 4, 1} = 8, índice = 1

Então, para k = 4 tem:

{-2, 3, 4, 1}, {3, 4, 1, 2}, {4, 1, 2, -1}, a maior soma, por enquanto, é de {3, 4, 1, 2} = 10, índice =1

Então, para k = 5 tem:

{-2, 3, 4, 1, 2}, {3, 4, 1, 2, -1}, a maior soma, por enquanto, é de {3, 4, 1, 2} = 10, índice = 1

Então, para k = 6 tem:

{-2, 3, 4, 1, 2, -1}, a maior soma de {3, 4, 1, 2} = 10

K chegou ao máximo.

Logo, determinou-se que o maior é, desde k = 4, índice = 1, o valor 10.

Correto @JorgeGus @nagatonie ?

[] — É programar o incremento de k, a "somatório", comparação e guarda k e o índice que começa [subarray] com maior valor.

Olá @Diovani Facco 

Considere haver capacidade no vetor, logo terá que sobrescrever os elementos de qualquer maneira ao copiar elementos a frente quando encontrar espaço em branco.

TESTE TESTE TESTE
     ^                                                           TESTE   TESTE TESTE
     |                                                                   ^
     +---------> a partir desse ponto                                    |
T, E são copiadas [para memoria temporaria] e atribui-se ' '' ' <+ ------+ 
S, T     //                //                //           T, E   |
...                                                              |
Até alcançar '\0' e depois o laço mais externo continua          |
do ponto, após a 1st atribuição ---------------------------------+

Esse plano faz sentido?

@immoraesz Olá! Por razão única da entrada

1 hora atrás, Alan Flanklyn disse:

printf("Digite uma palavra: ");

Você mesma(o) [quase] responde sua pergunta "na pergunta". Bem aqui

1 hora atrás, immoraesz disse:

for(i = 0; str[i] != '\0'; i++){
        }

Qual posição, i, ocupa antes que alcance '\0' desse ‘loop’? A posição da última 'letra' na palavra!

Logo, a última letra é o índice [i - 1]

char ola_eu_sou_a_ultima_letra = palavra[i - 1];

[] 

16 horas atrás, kalline disse:

Ola  o seguinte codigo é para reservar lugares no cinema usando vetores, minda duvida da vez é porque no codigo teve que ficar assim

reservas[numerocadeira] <- numerocadeira

numero de cadeiras é um contador?

Penso que a ideia é, pedir o número que identifica uma cadeira objetivando sua reserva, após ter exibido todos os números de cadeiras possíveis, porém não necessariamente disponíveis nas reservas. Daí a justificativa de uma verificação, após capturar o número da cadeira [sua identificação], pois caso a cadeira esteja 'livre', realiza-se sua reserva por meio desta expressão  '

reservas [numerocadeira] <- numerocadeira

', ou seja, uma cadeira reservada é aquela que o valor no índice do vetor de reservas é igual ao valor no subscrito, subscrito é variável que fica entre colchetes.

Suponha que

numerocadeira tem valor 3, logo se expressamos 
reservas[numerocadeira] <- numerocadeira
        ~~~~~~~~~~~~~~~    ~~~~~~~~~~~~~
            |                    |
            +-------> Índice     +---> subscrito

temos o mesmo, só que em valores o seguinte
reservas[3] <- 3

ou seja, depois disso a cadeira do índice 3 é uma reserva porque
o valor no ínidce [3] é igual ao do subscrito 3. 

Para tanto é necessária uma verificação que funcione!

[] 

@oromotoceu Olá!

Penso que reutilizou uma resposta ao exercício anterior que é semelhante. Sendo a pergunta a mesma: contar e buscar elementos do 'conjunto' chave no 'conjunto' fonte. No caso, o conjunto "key" que antes foi as vogais, agora necessita ser o caractere espaço e tabulação [acima citados]. Talvez dividir e conquistar uma solução que resolve para uma chave e depois reutilizar [em forma de função] no problema de muitas chaves simplifique o desenvolvimento e melhore a aprendizagem.

O procedimento mental [sem o uso da linguagem C] é quase igual à programação. Se parar e pensar no modo que faria para catar e contar formas/números específicos espelhadas na sala terá mesma impressão que usualmente: 1. Escolhe-se UMA das formas específicas [na ordem que estão], 2. Compara-se com as espelhadas, 3. Incrementa-se a quantidade acumulada quando uma das espalhadas é igual à específica, e repete essas etapas até a última das específicas.

Imagino que essa não é resposta que a maioria espera! É com intenção de fazer você começar de novo o código.

[] 

@MarianaN Olá.

Essa falha e outras são detectáveis, quase senão por todos, os compiladores. Para isso, incremente suas opções de Alerta [consulte o manual do IDE] para todos [-Wall] erros [-Werror]. Com isso será praticamente educado(a) pelo compilador, algo que é quase sempre o suficiente.

Veja

Uma imagem da falha

Com esses alerta, além de detecta a falha, exercita o inglês convenientemente!

[]  

@Prodigy085 Por que quer o sumiço do operador, especificamente, quando não apresenta erro?

Aqui:

11 horas atrás, Prodigy085 disse:

void LinkedList::clear() {
    while(m_head != nullptr) {auto *aux = m_head; m_head = m_head->next; delete aux;}
    m_size = 0;
}

Se não me engano, o endereço em aux é liberado de qualquer forma. E com uso de um dos "Smart Pointers" a destruição acontece, implicitamente, na atribuição do endereço seguinte.

Ou seja, implícito é legal?

[]