---

When programming, I often encounter cryptic error messages that make debugging a drawn-out and tedious affair. It appears that most compiler authors don't make explaining the error messages of their compilers a high priority, even though most beginners will stumble upon these errors eventually and will waste precious time trying to divine what the messages are actually trying to say - a bit like trying to learn a foreign language and understanding only half the vocabulary. Usually I search for error messages with my favorite search engine and hope to find an explanation or at least associated examples, but I'm unsuccessful too frequently for my taste. In the hopes of saving other programmers time, I have collected a couple of C++ error messages that I encountered while using the GNU C++ compiler (versions 4.9.2 to 9.4.0) together with minimal code examples to reproduce the errors, corrections for those examples, and occasional explanations. All code was compiled with

.

table of contents

• incomplete type
• incomplete template
• incomplete template the second
• give your template parameters real values
• missing default constructor
• initializing reference using a constant
• deleting instance of virtual class
• Doubled method
• Constructor has wrong name
• Don't forget your subclass declaration
• Trying to convert a lambda to a function pointer
• Redefinition of the same function in a different source file
• using a non-constant iterator on a constant string
• using a non-constant iterator on a constant vector
• automatic casting plus template deduction equals pain
• use delete() only on what has been created by new()
• trying to automatically cast a lambda
• trying to use a member function as a member variable
• invoking undefined behavior
• forgetting std::pair
• trying to allocate an array of pointers the wrong way
• trying implied multiplication for fun and education
• not everything is part of the std namespace
• trying to declare destructor without parentheses
• an extra comma
• main is not a variable
• accessing a member within the same (?) class
• sometimes you have to be explicit about what is a type
• Using a function as a constant
• Using a template function without template argument
• pointers to class methods have a hellish syntax
• std::stable_sort is not like std::sort
• switch without case

incomplete type

struct { int x; } my_struct;
int main() {
        struct my_struct x;
} 
 

instead of

struct my_struct { int x; };
int main() {
        struct my_struct x;
} 
 

results in .

incomplete template

template <class T>class A {};
template <class T>class B : A {};
int main () {} 
 

instead of

template <class T>class A {};
template <class T>class B : A<T> {};
int main () {} 
 

results in . or in or in The problem in all cases is using a template class without template arguments. If you actually want to use a template class without explicitly using template arguments, you'd have to provide default template arguments in the definition of the template in most cases.

incomplete template the second

template <class T>class A {};
int main () {
        A<int>* a = new A();
} 
 

instead of

template <class T>class A {};
int main () {
        A<int>* a = new A<int>();
} 
 

results in

give your template parameters real values

template <class T>class A {void foo();};
int main () {
        A<T>* a = new A<T>();
        a->foo();
} 
 

instead of

template <class T>class A {void foo();};
int main () {
        A<int>* a = new A<int>();
        a->foo();
} 
 

results in several error messages, among them But since this is probably not the first error message, you should pay attention to the first error message and fix that.

missing default constructor

class A {
        public:
                A(int x) {};
};
int main () {
        A a;
} 
 

or equivalently

class A {
        public:
                A(int x) {};
};
int main () {
        A a = A();
} 
 

instead of

class A {
        public:
                A() {};
                A(int x) {};
};
int main () {
        A a;
} 
 

results in . another example for the same problem:

class A{
        public:
                A(int x) {};
};
class B{
        A a;
};
int main () {
        B b;
} 
 

instead of

class A{
        public:
                A() {};
                A(int x) {};
};
class B{
        A a;
};
int main () {
        B b;
} 
 

relevant quote from cppreference.com that explains why this might be confusing (emphasis mine):

If no user-declared constructors of any kind are provided for a class type (struct, class, or union), the compiler will always declare a default constructor as an inline public member of its class.

So, if you add any non-default constructor, you have to provide the default constructor as well (if you want to use it), it will not be added automatically.

initializing reference using a constant

void f(int& x) {
}
int main() {
        f(42);
} 
 

instead of

void f(int& x) {
}
int main() {
        int x = 42;
        f(x);
} 
 

results in or in The problem is that a reference must point to an lvalue, in essence a variable, i.e. some place in memory where a value can be stored. An rvalue, in essence a constant or the value of some expression like "1+2", is not stored anywhere by default, it possesses no storage location by itself, and consequently the reference has nothing to point to. If you store the rvalue in an lvalue first, then you can reference that lvalue just fine. A somewhat unrelated problem is using

void f(int& x) {
}
int main() {
        int x = 42;
        f(&x);
} 
 

instead of

void f(int& x) {
}
int main() {
        int x = 42;
        f(x);
} 
 

which also resulted in in older compiler versions. Newer compiler produce the better error message The problem is just mixing up references and pointers. "&variable" in an expression always produces a pointer and you can't assign a pointer value to a reference.

deleting instance of virtual class

Using

class A {
        virtual void f() {};
};
int main() {
        A* a = new A();
        delete a;
} 
 

instead of

class A {
        void f() {};
};
int main() {
        A* a = new A();
        delete a;
} 
 

results in The warning explains the problem well, but careless copy/paste can make classes virtual by accident, which can make this warning confusing. Either make all methods non-virtual or add a virtual constructor to solve this.

Doubled method

class A {
        void f() {};
        //...
        void f() {};
};
int main () {
} 
 

instead of

class A {
        void f() {};
        //...
};
int main () {
} 
 

results in Another example of what can happen accidentally due to careless copy/paste, especially in large classes.

Constructor has wrong name

class A {
        B(){};
};
int main () {
} 
 

instead of

class A {
        A(){};
};
int main () {
} 
 

results in Another example of careless copy/paste. When you copy a class and then rename it, be sure to rename all constructors and other references to the old class name as well.

Don't forget your subclass declaration

class A {public:void foo();void bar();};
class B {public:void foo();};
int main () {
        B b;
        b.bar();
} 
 

instead of

class A {public:void foo();void bar();};
class B : public A {public:void foo();};
int main () {
        B b;
        b.bar();
} 
 

results in This one shouldn't be all that confusing, but it might still be surprising to see if you are convinced that you have already declared B a subclass of A.

Trying to convert a lambda to a function pointer

class A {
        public:
                void f(void (*g)()){
                        (*g)();
                }
};
int main () {
        A a;
        int x;
        a.f([&](){x=1;});
} 
 

instead of

class A {
        public:
                void f(void (*g)()){
                        (*g)();
                }
};
int main () {
        A a;
        int x;
        a.f([](){});
} 
 

results in in older compiler versions or results in in newer compiler versions. The new error message is somewhat understandable, but the old error message is very confusing if you don't understand the difference between lambdas with captures, lambdas without captures and function pointers. The code works if the lambda captures nothing (because such a lambda is just a normal function and the compiler can produce a pointer to its code), but fails to compile with a confusing error message if the lambda captures something. As far as I know, there is no simple way to convert such a lambda to a normal function, because the lambda needs to keep track of the captured variables and a function pointer can not carry this additional information (the function pointer is just a single number - the function code address). Lambdas without captures are of course much less powerful. So if you really need lambdas with captures, try the following:

class A {
        public:
                template<class G> 
                void f(G&& g){
                        g();
                }
};
int main () {
        A a;
        int x;
        a.f([&](){x=1;});
} 
 

Of course this requires a template method and this code could never be compatible with C. Lambdas without captures are probably compatible with C functions expecting function pointers and so cross-linking should be possible.

Redefinition of the same function in a different source file

If you have the three files test.cpp

#include "test.hpp"
int main() {
        f();
} 
 

test2.cpp

#include "test.hpp"
void g(){} 
 

and test.hpp

void f() {
} 
 

and compile both test.cpp and test2.cpp simultaneously, you won't get a compiler error (because the two files are compiled separately and so the compiler only ever sees one definition of function f at a time), but you will get the linker error , probably without any useful information about the location of the error. The problem is that the compiler outputs for test.cpp and test2.cpp have to be linked together for the final executable file, but both outputs contain definitions of function f - the linker doesn't know which one to use. But because by that time most information in the original source file has been thrown away, the linker can not give you much information about the cause/source-location of the error. The solution is to not put function definitions into your header files, only function declarations without function bodies should go there. The code will compile if function f is declared as "static void f()" and this usage of "static" does not do the same as "static" in a class method declaration - yes, I also find that name collision annoying.

using a non-constant iterator on a constant string

#include <string>#include <algorithm>int main() {
        const std::string s = "42";
        std::string::iterator it = std::find_if( s.begin() , s.end() , [](int c){return false;});
} 
 

instead of

#include <string>#include <algorithm>int main() {
        const std::string s = "42";
        std::string::const_iterator it = std::find_if( s.begin() , s.end() , [](int c){return false;});
} 
 

results in in older compiler versions or in newer compiler versions.

using a non-constant iterator on a constant vector

#include <vector>#include <algorithm>int main () {
        std::vector<int> a = {1,2,3};
        std::vector<int> b = {1,2,3};
        std::copy_if( a.cbegin() , a.cend() , b.begin() , [](int& i){return false;} );
} 
 

instead of

#include <vector>#include <algorithm>int main () {
        std::vector<int> a = {1,2,3};
        std::vector<int> b = {1,2,3};
        std::copy_if( a.cbegin() , a.cend() , b.begin() , [](const int& i){return false;} );
} 
 

results in The problem is the same as for the constant string: iterating over constant objects does not work with functions that expect access to non-constant variables.

automatic casting plus template deduction equals pain

#include <vector>#include <iostream>#include <numeric>int main() {
        std::vector<double> a = {1.4,2.6,3.7};
        double x = std::accumulate(a.begin(),a.end(),0,[](double accu,double e){return (accu+e);});
        std::cerr << x << std::endl;
} 
 

instead of

#include <vector>#include <iostream>#include <numeric>int main() {
        std::vector<double> a = {1.4,2.6,3.7};
        double x = std::accumulate(a.begin(),a.end(),0.0,[](double accu,double e){return (accu+e);});
        std::cerr << x << std::endl;
} 
 

will not result in a compiler error or linker error or even a runtime error, but it will break your heart and drive you insane. If you use 0 as an initialization for std::accumulate, C++ will consider it an integer, deduce that you want integer as std::accumulate's template parameter for the initialization value and automatically cast back and forth the value between integer and double, which of course includes rounding. Declaring that the accumulation function expects doubles is irrelevant. So giving the initialization value as 0.0 or better yet static_cast<double>(0.0) is probably what you want.

use delete() only on what has been created by new()

class A {};
int main() {
        A a;
        delete(&a);
} 
 

instead of

class A {};
int main() {
        A* a = new A();
        delete(a);
} 
 

will also not result in a compiler error or linker error, but it will produce the runtime error , because new() doesn't just reserve memory and create a pointer to that memory, it also creates management information that is needed so that delete()/free() can do its job. Thus you can't hand arbitrary pointers to delete();

trying to automatically cast a lambda

class A {
        public:
                void f(char(*g)(char c)) {
                        char c;
                        (*g)(c);
                }
};
int main() {
        A a;
        a.f([](double c){return c;});
} 
 

instead of

class A {
        public:
                void f(char(*g)(char c)) {
                        char c;
                        (*g)(c);
                }
};
int main() {
        A a;
        a.f([](char c){return c;});
} 
 

will result in

trying to use a member function as a member variable

class A {
        public:
                void f() {
                }
};
int main() {
        A a;
        a.f;
} 
 

instead of

class A {
        public:
                void f() {
                }
};
int main() {
        A a;
        a.f();
} 
 

will result in

invoking undefined behavior

#include <iostream> 
int main () {
        float sums[16];
        for( unsigned int k = 0 ; k <= 16 ; k++ ) {
                std::cerr << k << " " << sums[k] << std::endl;
        }
} 
 

instead of

#include <iostream> 
int main () {
        float sums[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
        for( unsigned int k = 0 ; k <= 16 ; k++ ) {
                std::cerr << k << " " << sums[k] << std::endl;
        }
} 
 

will result in the warning in older compiler versions or in newer compilers when compiled with the -O3 flag for aggressive optimization. The warning is not the puzzling part, the puzzling part is that the loop end is simply optimized away and the loop runs for many iterations until the program dies with a segmentation fault (SIGSEGV), because the loop body tried to access a protected memory location without permission. So, don't compile your code with -O3 before you've gotten rid of all warnings. And after that, make sure your code still passes all tests.

forgetting std::pair

#include <vector>int main () {
        std::vector<int,double> v;
} 
 

instead of

#include <vector>int main () {
        std::vector<std::pair<int,double>> v;
} 
 

will result in and and and many other errors, which look very confusing, because the compiler has no clue what you want from it when trying to instantiate a template class with the wrong number of template parameters. One problem is that std::vector takes two template parameters, but the second one is usually not specified explicitly and instead left at its default value. That is one example of the conflict between powerful flexibility (of templates and container classes) and simplicity/understandability.

trying to allocate an array of pointers the wrong way

class A{};
int main () {
        A** a = new (A*)[10];
} 
 

instead of

class A{};
int main () {
        A** a = new A*[10];
} 
 

will result in I really don't get why, but removing the parentheses solves the problem.

trying implied multiplication for fun and education

int main () {
        int x = 2 ( 3 + 4 );
} 
 

instead of

int main () {
        int x = 2 * ( 3 + 4 );
} 
 

will result in similarly

int main () {
        bool x = ( true == true ) ( false == false );
} 
 

instead of

int main () {
        bool x = ( true == true ) || ( false == false );
} 
 

will result in the same error.

not everything is part of the std namespace

class A{};
int main () {
        A* a = std::dynamic_cast<A*>(new A());
} 
 

instead of

class A{};
int main () {
        A* a = dynamic_cast<A*>(new A());
} 
 

will result in

trying to declare destructor without parentheses

class A {
        A();
        ~A;
};
int main () {} 
 

instead of

class A {
        A();
        ~A();
};
int main () {} 
 

will result in

an extra comma

void f(){}
int main () {
        f(1,);
} 
 

instead of

void f(){}
int main () {
        f(1);
} 
 

will result in

main is not a variable

int main {} 
 

instead of

int main () {} 
 

will result in

accessing a member within the same (?) class

template <class T> 
class A {
                void g();
        public:
                void f() {
                        A<int> a;
                        a.g();
                }
};
int main () {
        A<double> a;
        a.f();
} 
 

will result in , because class A is a template and A<int> is not the same class as A<double>. They are not even related. If you thought class A is the same irrespective of template parameters, you might get the impression that method f just calls method g within the same class, which should not run into any visibility issues.

sometimes you have to be explicit about what is a type

#include <vector> 
template <class T> 
void f() {
        std::vector<T>::iterator it;
}
int main () {} 
 

instead of

#include <vector> 
template <class T> 
void f() {
        typename std::vector<T>::iterator it;
}
int main () {} 
 

results in In related situations, you might get

Using a function as a constant

#include <string> 
int main () {
        char c;
        std::char_traits<char>::eof == c;
} 
 

instead of

#include <string> 
int main () {
        char c;
        std::char_traits<char>::eof() == c;
} 
 

results in

Using a template function without template argument

template <class T> 
void f(){}
int main () {
        f();
} 
 

instead of

template <class T> 
void f(){}
int main () {
        f<int>();
} 
 

results in

pointers to class methods have a hellish syntax

class A {
        public:
                void f();
};
int main () {
        A a;
        void (A::*ptr)() = &A::f;
        a.*ptr();
} 
 

instead of

class A {
        public:
                void f();
};
int main () {
        A a;
        void (A::*ptr)() = &A::f;
        (a.*ptr)();
} 
 

results in But on the other hand, using

class A {
        public:
                void f();
};
int main () {
        A a;
        void (A::*ptr)() = &(A::f);
        (a.*ptr)();
} 
 

instead of

class A {
        public:
                void f();
};
int main () {
        A a;
        void (A::*ptr)() = &A::f;
        (a.*ptr)();
} 
 

results in So you have to be really careful about parentheses, even though neither the error message or the Stroustrup book make this very clear.

std::stable_sort is not like std::sort

#include <vector> 
#include <algorithm> 
int main () {
        std::vector<int> v;
        std::stable_sort( v.begin() , v.end() , [](int& x,int& y){ return (x<y); } );
} 
 

instead of

#include <vector> 
#include <algorithm> 
int main () {
        std::vector<int> v;
        std::stable_sort( v.begin() , v.end() , [](const int& x,const int& y){ return (x<y); } );
} 
 

results in which is somewhat confusing, because it does work with std::sort instead of std::stable_sort. Of course you can just avoid using references in the comparator function if possible and suffer the cost of copying the vector elements.

switch without case

enum E {ONE,TWO};
int main () {
        E e;
        switch(e) {
                ONE:break;
                TWO:break;
        }
        switch(e) {
                ONE:break;
                TWO:break;
        }
} 
 

instead of

enum E {ONE,TWO};
int main () {
        E e;
        switch(e) {
                case ONE:break;
                case TWO:break;
        }
        switch(e) {
                case ONE:break;
                case TWO:break;
        }
} 
 

results in and The second is just a warning, but always appears. The first is an error, but only appears if you have two switch blocks. This might be particularly confusing if you've never used a label and don't know what it is. Similarly

int main () {
        int x;
        switch(x) {
                1:break;
                2:break;
        }
} 
 

instead of

int main () {
        int x;
        switch(x) {
                case 1:break;
                case 2:break;
        }
} 
 

results in and The difference is that labels can't start with digits, but case-expressions can.

Written by the author; Date 14.01.2026; © 2026 spinningsphinx.com

Paralinguistic/connotation key:

• Mocking
• Sarcasm, e.g. "Homeopathy fans are a really well-educated bunch"
• Statement not to be taken literally, e.g. "There is a trillion reasons not to go there"
• Non-serious/joking statement, e.g. "I'm a meat popsicle"
• Personal opinion, e.g. "I think Alex Jones is an asshole"
• Personal taste, e.g. "I like Star Trek"
• If I remember correctly
• Hypothesis/hypothetical speech, e.g. "Assuming homo oeconomicus, advertisement doesn't work"
• Unsure, e.g. "The universe might be infinite"
• 2 or more synonyms (i.e. not alternatives), e.g. "aubergine or eggplant"
• 2 or more alternatives (i.e. not synonyms), e.g. "left or right"
• A proper name, e.g. "Rome"

One always hopes that these wouldn't be necessary, but in the interest of avoiding ambiguity and aiding non-native English speakers, here they are. And to be clear: These are not guesses or suggestions, but rather definite statements made by the author. For example, if you think a certain expression would not usually be taken as a joke, but the author marks it as a joke, the expression shall be understood as a joke, i.e. the paralinguistic/connotation key takes precedence over the literal text. Any disagreement about the correct/incorrect usage of the expression may be ascribed to a lack of education and/or lack of tact on the part of the author if it pleases you.