c errors undefined reference
algoritmo de caminho mais curto em código-fonte java
Este tutorial detalha os erros críticos que os programadores freqüentemente encontram em C ++, como referência indefinida, uma falha de segmentação (despejo de núcleo) e símbolo externo não resolvido:
Discutiremos os erros mais importantes que costumamos encontrar em C ++ que são igualmente críticos. Além dos erros de sistema e de semântica e exceções que ocorrem de tempos em tempos, também obtemos outros erros críticos que afetam a execução de programas.
Esses erros ocorrem principalmente no final do programa em tempo de execução. Às vezes, o programa fornece a saída adequada e, em seguida, ocorre o erro.
=> Visite aqui para aprender C ++ do zero.
O que você aprenderá:
Erros importantes de C ++
Neste tutorial, discutiremos três tipos de erros que são críticos do ponto de vista de qualquer programador C ++.
- Referencia indefinida
- falha de segmentação (despejo de núcleo)
- Símbolo externo não resolvido
Discutiremos as possíveis causas de cada um desses erros e, juntamente com os cuidados que podemos tomar como programadores, para evitar esses erros.
Vamos começar!!
Referencia indefinida
Um erro de “Referência indefinida” ocorre quando temos uma referência ao nome do objeto (classe, função, variável, etc.) em nosso programa e o vinculador não consegue encontrar sua definição quando tenta procurá-lo em todos os arquivos e bibliotecas de objetos vinculados .
Assim, quando o vinculador não consegue encontrar a definição de um objeto vinculado, ele emite um erro de “referência indefinida”. Como fica claro pela definição, esse erro ocorre nas fases posteriores do processo de vinculação. Existem vários motivos que causam um erro de “referência indefinida”.
Discutimos alguns desses motivos abaixo:
# 1) Nenhuma definição fornecida para o objeto
Esta é a razão mais simples para causar um erro de “referência indefinida”. O programador simplesmente se esqueceu de definir o objeto.
Considere o seguinte programa C ++. Aqui, especificamos apenas o protótipo da função e, em seguida, o usamos na função principal.
#include int func1(); int main() { func1(); }Resultado:
Portanto, quando compilamos este programa, o erro do vinculador que diz 'referência indefinida para‘ func1 () ’' é emitido.
Para nos livrarmos desse erro, corrigimos o programa da seguinte maneira, fornecendo a definição da função func1. Agora o programa fornece a saída apropriada.
#include using namespace std; int func1(); int main() { func1(); } int func1(){ cout<<'hello, world!!'; }Resultado:
Olá Mundo!!
# 2) Definição errada (assinaturas não correspondem) de objetos usados
Ainda outra causa para o erro de “referência indefinida” é quando especificamos definições erradas. Usamos qualquer objeto em nosso programa e sua definição é algo diferente.
Considere o seguinte programa C ++. Aqui, fizemos uma chamada para func1 (). Seu protótipo é int func1 (). Mas sua definição não combina com seu protótipo. Como vemos, a definição da função contém um parâmetro para a função.
Portanto, quando o programa é compilado, a compilação é bem-sucedida devido ao protótipo e à correspondência da chamada de função. Mas quando o vinculador está tentando vincular a chamada de função com sua definição, ele encontra o problema e emite o erro como “referência indefinida”.
#include using namespace std; int func1(); int main() { func1(); } int func1(int n){ cout<<'hello, world!!'; }Resultado:
Assim, para evitar esses erros, simplesmente verificamos se as definições e o uso de todos os objetos estão combinando em nosso programa.
# 3) Arquivos de objeto não vinculados corretamente
Este problema também pode dar origem ao erro de “referência indefinida”. Aqui, podemos ter mais de um arquivo fonte e podemos compilá-los independentemente. Quando isso é feito, os objetos não são vinculados corretamente e resulta em “referência indefinida”.
Considere os dois programas C ++ a seguir. No primeiro arquivo, fazemos uso da função “print ()” que é definida no segundo arquivo. Quando compilamos esses arquivos separadamente, o primeiro arquivo fornece “referência indefinida” para a função de impressão, enquanto o segundo arquivo fornece “referência indefinida” para a função principal.
int print(); int main() { print(); }Resultado:
int print() { return 42; }Resultado:
A maneira de resolver este erro é compilar os dois arquivos simultaneamente ( Por exemplo, usando g ++).
Além das causas já discutidas, “referência indefinida” também pode ocorrer pelos seguintes motivos.
# 4) Tipo de projeto errado
Quando especificamos tipos de projeto errados em IDEs C ++ como o visual studio e tentamos fazer coisas que o projeto não espera, obtemos “referência indefinida”.
# 5) Sem biblioteca
Se um programador não especificou o caminho da biblioteca corretamente ou se esqueceu completamente de especificá-lo, obtemos uma “referência indefinida” para todas as referências que o programa usa da biblioteca.
# 6) Arquivos dependentes não são compilados
Um programador deve garantir que compilamos todas as dependências do projeto de antemão para que, ao compilar o projeto, o compilador encontre todas as dependências e as compile com sucesso. Se alguma das dependências estiver faltando, o compilador fornecerá uma “referência indefinida”.
Além das causas discutidas acima, o erro de “referência indefinida” pode ocorrer em muitas outras situações. Mas o ponto principal é que o programador errou as coisas e, para evitar esse erro, elas devem ser corrigidas.
conversor do youtube para mp3 grátis seguro
Falha de segmentação (despejo de núcleo)
O erro “falha de segmentação (core despejado)” é um erro que indica corrupção de memória. Geralmente ocorre quando tentamos acessar uma memória que não pertence ao programa em consideração.
Aqui estão alguns dos motivos que causam o erro de falha de segmentação.
# 1) Modificando a string constante
Considere o programa a seguir, no qual declaramos uma string constante. Então, tentamos modificar essa string constante. Quando o programa é executado, obtemos o erro mostrado na saída.
#include int main() { char *str; //constant string str = 'STH'; //modifying constant string *(str+1) = 'c'; return 0; } Resultado:
# 2) Ponteiro de desreferenciação
Um ponteiro deve apontar para um local de memória válido antes de desreferenciá-lo. No programa abaixo, vemos que o ponteiro está apontando para NULL, o que significa que o local da memória para o qual ele está apontando é 0, ou seja, inválido.
Portanto, quando removemos a referência dele na próxima linha, estamos na verdade tentando acessar sua localização de memória desconhecida. Isso realmente resulta em uma falha de segmentação.
#include using namespace std; int main() { int* ptr = NULL; //here we are accessing unknown memory location *ptr = 1; cout << *ptr; return 0; } Resultado:
falha de segmentação
O próximo programa mostra um caso semelhante. Também neste programa, o ponteiro não aponta para dados válidos. Um ponteiro não inicializado é tão bom quanto NULL e, portanto, também aponta para um local de memória desconhecido. Portanto, quando tentamos desreferenciá-lo, isso resulta em uma falha de segmentação.
#include using namespace std; int main() { int *p; cout<<*p; return 0; } Resultado:
falha de segmentação
Para evitar tais erros, temos que garantir que nossas variáveis de ponteiro no programa apontem sempre para localizações de memória válidas.
# 3) Stack Overflow
Quando temos chamadas recursivas em nosso programa, elas consomem toda a memória da pilha e fazem com que ela transborde. Nesses casos, obtemos a falha de segmentação, pois ficar sem memória de pilha também é um tipo de corrupção de memória.
Considere o programa abaixo, onde calculamos o fatorial de um número recursivamente. Observe que nossa condição de base testa se o número é 0 e depois retorna 1. Este programa funciona perfeitamente para números positivos.
Mas o que acontece quando realmente passamos um número negativo para uma função fatorial? Bem, como a condição básica não é fornecida para os números negativos, a função não sabe onde parar e, portanto, resulta em um estouro de pilha.
Isso é mostrado na saída abaixo que fornece falha de segmentação.
#include using namespace std; int factorial(int n) { if(n == 0) { return 1; } return factorial(n-1) * n; } int main() { cout< Resultado:
falha de segmentação (despejo de núcleo)
Agora, para corrigir esse erro, mudamos ligeiramente a condição de base e também especificamos o caso para números negativos, conforme mostrado abaixo.
#include using namespace std; int factorial(int n) { // What about n <0? if(n <= 0) { return 1; } return factorial(n-1) * n; } int main() { cout<<'Factorial output:'< Resultado:
Saída fatorial: 1
Agora vemos que a falha de segmentação foi resolvida e o programa funciona bem.
Símbolo externo não resolvido
O símbolo externo não resolvido é um erro do vinculador que indica que não foi possível encontrar o símbolo ou sua referência durante o processo de vinculação. O erro é semelhante a “referência indefinida” e é emitido de forma intercambiável.
Fornecemos dois exemplos abaixo em que esse erro pode ocorrer.
# 1) Quando nos referimos a uma variável de estrutura no programa que contém um membro estático.
#include struct C { static int s; }; // int C::s; // Uncomment the following line to fix the error. int main() { C c; C::s = 1; } Resultado:
No programa acima, a estrutura C tem membros estáticos que não são acessíveis aos programas externos. Portanto, quando tentamos atribuir a ele um valor na função principal, o vinculador não encontra o símbolo e pode resultar em um 'símbolo externo não resolvido' ou 'referência indefinida'.
A maneira de corrigir esse erro é explicitamente definir o escopo da variável usando ‘::’ fora do principal antes de usá-lo.
# 2) Quando temos variáveis externas referenciadas no arquivo de origem e não vinculamos os arquivos que definem essas variáveis externas.
Este caso é demonstrado abaixo:
java pass array para método por referência
#include #include using namespace std; extern int i; extern void g(); void f() { i++; g(); } int main() {} Resultado:
Em geral, no caso de um 'símbolo externo não resolvido', o código compilado para qualquer objeto como função não consegue encontrar um símbolo ao qual faz uma referência, talvez porque esse símbolo não esteja definido nos arquivos de objeto ou em qualquer uma das bibliotecas especificado para o vinculador.
Conclusão
Neste tutorial, discutimos alguns erros importantes em C ++ que são críticos e podem afetar o fluxo do programa e podem até resultar em um travamento do aplicativo. Exploramos em detalhes tudo sobre falha de segmentação, símbolo externo não resolvido e referência indefinida.
Embora esses erros possam ocorrer a qualquer momento, pelas causas que discutimos, sabemos que podemos evitá-los facilmente desenvolvendo cuidadosamente nosso programa.
=> Leia a série de treinamento Easy C ++.
Leitura recomendada
