Learn about the different types of errors and practicing looking for them.

Errors

Sometimes the code compiles fine, but there is still a message because the program needs some function or library that it can't find. This is known as a link-time error.

As our program gets bigger, it is good practice to divide the program into separate files. After compiling them, the _linker_ takes those separate object files and combines them into a single executable file. Link-time errors are found by the linker when it is trying to combine object files into an executable file.

Some common link-time errors:

- Using a function that was never defined (more on this later)
- Writing `Main()` instead of `main()`

Here’s an example of a link-time error message:

![/usr/lib/gcc/x86_64-linux-gnua/7/../../../x86_64-linux](https://content.codecademy.com/courses/learn-cpp/loops/link-time-error.png)

These errors are more hard to find, but remember, [Google](https://www.google.com) is your friend! Here, a good Google search would be: "C++ undefined reference to main".


Link-time Errors

Finding bugs is a huge part of a programmer’s life. Don’t be intimidated by them… embrace them. Errors in your code mean you're trying to do something cool!

In this lesson, we have learned about the four types of C++ errors:

- **Compile-time errors:** Errors found by the compiler.
- **Link-time errors:** Errors found by the linker when it is trying to combine object files into an executable program.
- **Run-time errors:** Errors found by checks in a running program.
- **Logic errors:** Errors found by the programmer looking for the causes of erroneous results.

Remember, [Google](https://www.google.com) and [Stack Overflow](https://www.stackoverflow.com) are a programmer's best friends. For some more motivation, check out this blog post: [Thinking About Errors in Your Code Differently](https://news.codecademy.com/errors-in-code-think-differently).

We wish you the best of luck in your bug-squashing journey.

Review

Once we have removed the compile-time errors, link-time errors, and run-time errors, the program runs successfully. But sometimes, the program doesn't do what we want it to do or no output is produced. Hmmm...

These types of errors which provide incorrect output, but appears to be error-free, are called logical errors. These are one of the most common errors that happen to beginners and also usually the most difficult to find and eliminate.

Logical errors solely depend on the logical thinking of the programmer. Your job now is to figure out why the program didn't do what you wanted it to do.

Some common logic errors:

- Program logic is flawed
- Some "silly" mistake in an `if` statement or a `for`/`while` loop

**Note:** Logic errors don't have error messages. Sometimes, programmers use a process called [test-driven development (TDD)](https://en.wikipedia.org/wiki/Test-driven_development), a way to give logic errors error messages and save yourself a lot of headaches!



Logic Errors

_"First actual case of bug being found."_

The story goes that on September 9<sup>th</sup>, 1947, computer scientist <a href="https://en.wikipedia.org/wiki/Grace_Hopper" target="_blank">Grace Hopper</a> found a moth in the Harvard Mark II computer's log book and reported the world's first literal computer bug. However, the term "bug", in the sense of technical error, dates back at least to 1878 and with Thomas Edison.

On your programming journey, you are destined to encounter innumerable red errors. Some even say, that debugging is over 75% of the development time. But what makes a programmer successful isn't avoiding errors, it's knowing how to find the solution.

In C++, there are many different ways of classifying errors, but they can be boiled down to four categories:

- **Compile-time errors:** Errors found by the compiler. 
- **Link-time errors:** Errors found by the linker when it is trying to combine object files into an executable program.
- **Run-time errors:** Errors found by checks in a running program.
- **Logic errors:** Errors found by the programmer looking for the causes of erroneous results.

In this mini-lesson, we will be looking at different errors and different error messages, and we'll teach you how to think about errors in your code a little differently.

Introduction to Bugs

If our program has no compile-time errors and no link-time errors, it'll run. This is where the fun really starts.

Errors which happen during program execution (run-time) after successful compilation are called run-time errors.  Run-time errors occur when a program with no compile-time errors and link-time errors asks the computer to do something that the computer is unable to reliably do.

It happens after we give the `./` execute command:

```
./a.out
```

Some common run-time errors:

- Division by zero also known as *division error*. These types of error are hard to find as the compiler doesn’t point to the line at which the error occurs.
- Trying to open a file that doesn't exist

There is no way for the compiler to know about these kinds of errors when the program is compiled.

Here's an example of a run-time error message:

![Floating point exception (core dumped)](https://content.codecademy.com/courses/learn-cpp/loops/run-time-error.png)


Run-time Errors

When we are writing C++ programs, the compiler is our first line of defense against errors.

There are two types of compile-time errors:

- **Syntax errors**: Errors that occur when we violate the rules of C++ syntax.
- **Type errors**: Errors that occur when there are mismatch between the types we declared.

Some common syntax errors are:

- Missing semicolon `;`
- Missing closing parenthesis `)`, square bracket `]`, or curly brace `}`

Some common type errors are:

- Forgetting to declare a variable
- Storing a value into the wrong type

Here's an example of a compile-time error message:

![$ g++ example.cpp example.cpp: In function 'int main()': examplecpp:5:11: error: invalid conversion from 'const char*' to 'int' [-fpermissive] int x = "hello";](https://content.codecademy.com/courses/learn-cpp/loops/compile-time-error.png)

The compiler will tell us where (line number) it got into trouble and its best guess as to what is wrong.