Nevado4ka 0 / 0 / 0 Регистрация: 18.11.2011 Сообщений: 45 |
||||
1 |
||||
19.04.2012, 22:18. Показов 12328. Ответов 4 Метки нет (Все метки)
помогите пожалуйста, почему вот тут вылезает ошибка «statement cannot resolve address of overloaded function»? в строке, где я вызываю функцию BuiltRing
__________________
0 |
Псевдослучайный 1946 / 1145 / 98 Регистрация: 13.09.2011 Сообщений: 3,215 |
|
19.04.2012, 22:24 |
2 |
Зачем в 34 и 40 скобки?
0 |
0 / 0 / 0 Регистрация: 18.11.2011 Сообщений: 45 |
|
20.04.2012, 19:20 [ТС] |
3 |
не знаю, это я с интернета взяла кусок кода
0 |
diagon Higher 1953 / 1219 / 120 Регистрация: 02.05.2010 Сообщений: 2,925 Записей в блоге: 2 |
||||||||||||||||
20.04.2012, 19:43 |
4 |
|||||||||||||||
Не очень логичный код, но, насколько я угадал, вам нужно заменить
На
И
на
1 |
0 / 0 / 0 Регистрация: 18.11.2011 Сообщений: 45 |
|
20.04.2012, 21:44 [ТС] |
5 |
ох, спасибо большое))
0 |
- Forum
- General C++ Programming
- Error: statement cannot resolve address
Error: statement cannot resolve address of overloaded function
I can’t seem to figure out whats causing this error: statement cannot resolve address of overloaded function . Error is before line 14 in bubblesortrand function. Thnx in advance.
|
|
|
|
Last edited on
You forgot to append the function call operator to datafile.close.
It should look like this: datafile.close()
Thnx alot
Now that i fixed the syntax error the program runs, but there is a runtime error because it crashes when i call the function. Im trying to make the function display sorted list using the bubble sort, am i going about this the right way with the bubblesortrand funtion?
Last edited on
http://www.cplusplus.com/forum/general/112111/
`x’ is uninitialized
`input’ is uninitialized, ¿what’s the point of sorting it?
Your reading condition is incorrect and will process an extra line.
> Im trying to make the function display sorted list using the bubble sort
read a list.
sort a list.
print a list.
Don’t try to sort until you finished the reading.
thnx
Topic archived. No new replies allowed.
abstract declarator ‘TYPE’ used as declaration[edit | edit source]
- Message found in GCC version 4.5.1
- often grouped together with:
- member ‘DATA_MEMBER’ with constructor not allowed in anonymous aggregate
- member ‘DATA_MEMBER’ with destructor not allowed in anonymous aggregate
- member ‘DATA_MEMBER’ with copy assignment operator not allowed in anonymous aggregate
- often grouped together with:
- a class or struct is missing a name:
struct { // error, no name int bar; };
- a header file has a class or struct with a name already used inside ifndef, define statements
#ifndef foo #define foo #include <vector> struct foo { // error, foo already in use std::vector<int> bar; }; #endif
call of overloaded ‘FUNCTION’ is ambiguous[edit | edit source]
‘VARIABLE’ cannot appear in a constant-expression[edit | edit source]
‘VARIABLE’ cannot be used as a function[edit | edit source]
- Message found in GCC version 4.5.1
- make sure the variable name does not have an underscore in it (compiler weirdness)
- you’re using the same name for a variable name and a function inside a function definition
int foo(int baf) { return baf; } int bar(int foo) { foo = foo(4); return foo; }
conversion from ‘TYPE’ to non-scalar type ‘TYPE’ requested[edit | edit source]
- Message found in GCC version 4.5.1
- type conversion error, look for missing «::» syntax or missing parenthesis
- possibly a casting error
- a class member function returns a value that does not match the function’s declared return type
class Foo { public: int x; }; class Bar { public: Foo Maz() { return 0; } // 0 is of type int, not Foo };
could not convert ‘STATEMENT’ to ‘bool’[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- you a mistyped comparison operator (e.g., using: «=» instead of «==»)
- you used an incorrect return type for the called function’s definition
// you had: foo operator<(const foo & f) const // instead of: bool operator<(const foo & f) const
- you’re using an invalid argument for a conditional statement
string x = "foo"; if (x) cout << "true" << endl;
declaration of ‘FUNCTION’ outside of class is not definition[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- try using ‘=’ to initialize a value instead of parenthesis
- you used a semicolon or comma between a constructor and an initializer list instead of a colon
- you left a semicolon before the body of a function definition
class Foo { public: int bar; Foo(int x); }; Foo::Foo(int x); // semicolon ';' needs to be removed { bar = x; }
declaration of ‘VARIABLE’ shadows a parameter[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- you’re redefining a variable name that’s already in use, possibly declared in the function’s parameter list
int foo(int bar) { int bar; return bar; }
‘TYPE’ does not name a type[edit | edit source]
- Message found in GCC version 4.5.1
- in GCC version 3.2.3 sometimes reported as: syntax error before ‘CHARACTER’ token
- in GCC version 4.0.1, sometimes reported as: ISO C++ forbids declaration
- e.g.: ISO C++ forbids declaration of ‘vector’ with no type
- you left out an object’s name qualifier or using directive
ostream & os; // instead of: std::ostream & os;
- make sure you didn’t mistype the scope operator «::», e.g.: «name:name» instead of «name::name»
- make sure you included the required libraries
#include <iostream> // missing vector library include class Foo { public: std::vector<int> Bar(std::vector<int> FooBar) { return FooBar; } };
- a header file is listed after a file that makes use of it in the include directives
// test.h file #ifndef TEST_H_ #define TEST_H_ std::string bar; #endif // test.cpp file #include "test.h" #include <iostream> // error, needed before test.h using namespace std; int main() { cout << bar << endl; return 0; }
expected ‘TOKEN’ before ‘TOKEN’ token[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- in GCC version 3.2.3 sometimes reported as: syntax error before ‘CHARACTER’ token
- check for a missing comma or parenthesis in a function’s parameters
- check for a missing semicolon
- e.g.: expected ‘,’ or ‘;’ before ‘TOKEN’
const int MAX = 10 // error int main() { string foo; cout << foo.size(); return 0; }
- possibly from a double namespace definition, or a fully-qualified (e.g., std::cout) name already under a ‘using’ directive
- possible missing ‘<<‘ or ‘>>’ operator in a cin/cout statement
int foo = 0, bar = 0; cin foo >> bar; // should be: cin >> foo >> bar;
expected primary-expression before ‘TOKEN’[edit | edit source]
- expected primary-expression before ‘int’
- Message found in GCC version 4.5.1
- in GCC version 3.2.3 reported as: parse error before ‘)’ token
- one likely cause is using (or leaving in) a type name in a function call
int sum(int x, int y) { return (x + y); } int main() { int a = 4, b = 5; sum(a, int b); // int is the problem causer return 0; }
expected unqualified-id before[edit | edit source]
- Message found in GCC version 4.5.1
- check your syntax for missing, misplaced, or erroneous characters
- expected unqualified-id before ‘(‘ token
- e.g.: parentheses in a class name
class Foo() { public: int x; };
- expected unqualified-id before ‘return’
- e.g.: missing opening brace in a conditional statement
int foo = 3, bar = 2; if (foo > bar) // error, no "{" cout << foo << endl; }
incompatible types in assignment of ‘TYPE’ to ‘TYPE’[edit | edit source]
- Message found in GCC versions 4.5.1
- you’re trying to assign to or initialize a character array using a character pointer
- e.g.: incompatible types in assignment of ‘const char*’ to ‘char [10]’
char bar[10]; const char *foo = "ppp"; bar = *foo; // error // possible fix, use strcpy from the cstring header: char bar[10]; const char *foo = "ppp"; strcpy(bar, foo);
- improperly accessing elements of a 2D array
char foo[2][3]; foo[1] = ' '; // error, need both dimensions, eg: foo[1][0] = ' ';
invalid conversion from ‘TYPE’ to ‘TYPE’[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- make sure parentheses were not left out of a function name
- make sure you are passing a function the correct arguments
char foo = 'f'; char bar[] = "bar"; if (strcmp(foo, bar) != 0) cout << "Correct answer!"; // strcmp was expecting 2 character pointers, foo doesn't qualify
invalid operands of types ‘TYPE’ and ‘TYPE’ to binary ‘FUNCTION’[edit | edit source]
- Message found in GCC version 4.5.1
- You’re trying to concatenate to C string arguments with the addition operator
// attempting to combine two C-strings cout << "abc" + "def"; // possible fix: convert 1 argument to a string type cout << "abc" + string("def");
invalid use of template-name[edit | edit source]
- invalid use of template-name ‘TEMPLATE’ without an argument list
- Message found in GCC version 4.5.1
- often paired with: expected unqualified-id before ‘TOKEN’
- in GCC version 3.2.3 reported as: syntax error before ‘CHARACTER’ token
- the type is missing after the class name in a function definition
template <class T> class Foo { private: int x; public: Foo(); }; template<class T> Foo::Foo() { x = 0; } // error, should be: Foo<T>::Foo()
is not a member of[edit | edit source]
- Message found in GCC versions 4.5.1
- check for a missing header include
- example: ‘cout’ is not a member of ‘std’
// test.cpp // file is missing iostream include directive int main() { std::cout << "hello, world!n"; return 0; }
‘TYPE’ is not a type[edit | edit source]
- Message found in GCC version 4.5.1
- in GCC version 3.2.3 reported as: type specifier omitted for parameter ‘PARAMETER’
- you mistyped a template parameter in a function declaration
void foo(int x, vector y);
- an included header file does not have the correct libraries included in the source file to implement it:
- e.g.: you’re using #include «bar.h» without including the «foo.h» that «bar.h» needs to work
- Check that there are no methods with the same name as ‘TYPE’.
‘CLASS_MEMBER’ is private within this context[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- usually reported in the format:
- (LOCATION_OF_PRIVATE_DATA_MEMBER) error: ‘DATA_MEMBER’ is private
- (LOCATION_OF_CODE_ACCESSING_PRIVATE_DATA) error: within this context
- Message usually results from trying to access a private data member of a class or struct outside that class’s or struct’s definition
- Make sure a friend member function name is not misspelled
class FooBar { private: int bar; public: friend void foo(FooBar & f); }; void fooo(FooBar & f) { // error f.bar = 0; }
- make sure a read only function is using a ‘const’ argument type for the class
- make sure functions that alter data members are not const
- check for derived class constructors implicitly accessing private members of base classes
class Foo { private: Foo() {} public: Foo(int Num) {} }; class Bar : public Foo { public: Bar() {} // Bar() implicitly accesses Foo's private constructor };
- solution 1: use an initializer list to bypass implicit initialization
- solution 2: make the accessed base class member protected instead of private
- You’re trying to initialize a contained class member by accessing private data
class Foo { private: char mrStr[5]; public: Foo(const char *s = "blah") { strcpy(mrStr, s); } }; class Bar { private: int mrNum; Foo aFoo; public: Bar(int n, const Foo &f); }; // error, attempting to use the Foo class constructor by accessing private data: Bar::Bar(int n, const Foo &f) : aFoo(f.mrStr) { // mrStr is private mrNum = n; }
possible fix, assign the whole object rather than part of it:
Bar::Bar(int n, const Foo &f) : aFoo(f) { mrNum = n; }
ISO C++ forbids declaration of ‘FUNCTION’ with no type[edit | edit source]
- Message found in GCC version 3.2.3, 4.5.1
- you’ve created a function with no listed return type
Foo() { return 0: } // should be: int Foo() { return 0: }
multiple definitions of[edit | edit source]
- eg: multiple definition of `main’
- Message found in GCC version 4.5.1
- check for missing inclusion guard in header file
- check for duplicate file listing in compile commands / makefile
- e.g.: g++ -o foo foo.cpp foo.cpp
- check for definitions rather than only declarations in the header file
‘CLASS FUNCTION(ARGUMENTS)’ must have an argument of class or enumerated type[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- you’re attempting to access members of a class with a non-member function
- non-member functions must access class members explicitly
- eg: CLASS_NAME FUNCTION_NAME(CLASS_NAME OBJECT_NAME, ARGUMENTS)
- you’re redefining an operator for a standard (built-in) type
class Foo { public: friend int operator+(int x, int y); };
new types may not be defined in a return type[edit | edit source]
- Message found in GCC version 4.5.1
- in GCC version 3.2.3, reported as:
-
- semicolon missing after definition of ‘CLASS’
- ISO C++ forbids defining types within return type
- check for a missing semicolon at the end of a class definition
class Foo { public: int x; } // Error
no match for call to ‘FUNCTION’[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- make sure the function’s namespace is used ( using namespace std / std::function() )
- make sure the function name is not misspelled, parentheses aren’t missing
- make sure the function is called with the correct arguments / types / class
- if you’re initializing a variable via parentheses, if there’s underscores in the variable name try removing them. Sometimes an equals sign is the only way…
- you’re using the same name for a variable and a function within the same namespace
string bar() { string foo = "blah"; return foo; } int main() { string bar; bar = bar(); // error, "bar()" was hidden by string initialization return 0; }
no matching function for call to ‘FUNCTION’[edit | edit source]
- Message found in GCC version 4.5.1
- make sure there aren’t parentheses where there shouldn’t be (e.g.: classname::value() instead of classname::value )
- you’re using a string argument with a function that expects a C-string
// broken code ifstream in; string MrString = "file.txt"; in.open(MrString); // solution: convert the string to a C-string ifstream in; string MrString = "file.txt"; in.open(MrString.c_str());
non-constant ‘VARIABLE’ cannot be used as template argument[edit | edit source]
- Message found in GCC version 3.2.3
- in GCC version 4.5.1 reported as: ‘VARIABLE’ cannot appear in a constant-expression
- variable used for a template argument, which are required to be constant at compile time
template <class T, int num> class Bar { private: T Foo[num]; }; int main() { int woz = 8; Bar<double, woz> Zed; // error, woz is not a constant return 0; }
non-member function ‘FUNCTION’ cannot have cv-qualifier[edit | edit source]
- error: non-member function ‘int Foo()’ cannot have cv-qualifier
- cv = constant / volatile
- Message found in GCC version 4.5.1
- you’re using the ‘post’ const (constant value) on a non-member function
- you’re not using the scope qualifier («TYPENAME::») in the function definition
- you mistyped the definition for a template class’s member function
template<class Type> class Foo { private: int stuff; public: int bar() const; }; template<class Type> int Foo::bar() const { // error return stuff; }
possible fix:
template<class Type> int Foo<Type>::bar() const { return stuff; }
passing ‘const OBJECT’ as ‘this’ argument of ‘FUNCTION’ discards qualifiers[edit | edit source]
- Message found in GCC version 4.5.1
- you’re returning an address
- you’re attempting to access a container element with a const_iterator using a member function that has no non-const versions. The non-const function does not guarantee it will not alter the data
request for member ‘NAME’ in ‘NAME’, which is of non-class type ‘CLASS’[edit | edit source]
- Message found in GCC versions 4.5.1
- in GCC version 3.2.3 reported as:
-
- request for member ‘NAME’ in ‘NAME’, which is of non-aggregate type ‘TYPE’
- check the function call in the code, it might be calling a function with incorrect arguments or it might have misplaced/missing parenthesis
- your using the «*this» pointer where you should just be using the functions name
- e.g., use: return mem_func(); instead of: return *this.mem_func();
- using the «*this» pointer with the wrong syntax
class Foo { public: int x; Foo(int num = 0) { x = num; } void newX(int num); }; void Foo::newX(int num) { *this.newX(num); // error, need (*this).newX or this->newX }
statement cannot resolve address of overloaded function[edit | edit source]
- Message found in GCC versions 3.2.3, 4.5.1
- make sure you’re not forgetting the parenthesis after a member function name
class Foo { public: int Bar() { return 0; } }; int main() { Foo x; x.Bar; // error return 0; }
two or more data types in declaration of ‘NAME’[edit | edit source]
- Message found in GCC version 4.5.1
- in GCC version 3.2.3 reported as: extraneous ‘TYPE’ ignored
- you have multiple data types listed for a function declaration’s return value
int char sum(int x, int y); // int char
- possibly a missing semicolon in between 2 type declarations
- usually missing in a function, struct, or class declaration after the curly braces {}
<GOBBLEDEGOOK> undefined reference to <GOBBLEDEGOOK>[edit | edit source]
- Message found in GCC version 4.5.1
- in GCC versions 4.0.1, 4.2.1 reported as: Undefined symbols
- check for a missing or mistyped header includes
- check for a missing or mistyped files/libraries in a project/make file
- check for a missing, mistyped, or undefined functions or class constructors
// header file void foo(); void bar(); void baz(); // implementation file, bar definition is missing void foo() { cout << "foon"; } void baz() { cout << "bazn"; }
- check for function declarations that do not match their definitions
- make sure function names do not overlap those in existing header files
- make sure compile commands syntax / makefile structure is correct (e.g.: g++ -o file.cc … etc.)
- no main() function is defined in any of the files inside a project/makefile
- e.g.: undefined reference to `WinMain@16′
‘NAME’ was not declared in this scope[edit | edit source]
- Message found in GCC version 4.5.1
- in GCC versions 3.2.3 reported as: ‘FUNCTION’ undeclared (first use of this function)
- look for a misspelled or changed variable/function/header call name
lonh wait; // instead of: long wait;
- make sure the proper header and library files are included
- defined variables may need the headers they utilize included in all files that use the defined variables
std::endl
is a function template. Normally, its used as an argument to the insertion operator <<
. In that case, the operator<<
of the stream in question will be defined as e.g. ostream& operator<< ( ostream& (*f)( ostream& ) )
. The type of the argument of f
is defined, so the compiler will then know the exact overload of the function.
Its comparable to this:
void f( int ){}
void f( double ) {}
void g( int ) {}
template<typename T> void ft(T){}
int main(){
f; // ambiguous
g; // unambiguous
ft; // function template of unknown type...
}
But you can resolve the ambiguity by some type hints:
void takes_f_int( void (*f)(int) ){}
takes_f_int( f ); // will resolve to f(int) because of `takes_f_int` signature
(void (*)(int)) f; // selects the right f explicitly
(void (*)(int)) ft; // selects the right ft explicitly
Thats what happens normally with std::endl
when supplied as an argument to operator <<
: there is a definition of the function
typedef (ostream& (*f)( ostream& ) ostream_function;
ostream& operator<<( ostream&, ostream_function )
And this will enable the compiler the choose the right overload of std::endl
when supplied to e.g. std::cout << std::endl;
.
Nice question!
The most likely reason I can think of is that its declaration is:
ostream& endl ( ostream& os );
In other words, without being part of a <<
operation, theres no os
that can be inferred. Im pretty certain this is the case since the line:
std::endl (std::cout);
compiles just fine.
My question to you is: why would you want to do this?
I know for a fact that 7;
is a perfectly valid statement in C but you dont see that kind of rubbish polluting my code 🙂
C++ – statement cannot resolve address for overloaded function
std::endl
is a function template. If you use it in a context where the template argument cannot be uniquely determined you have to disambiguate which specialization you mean. For example you can use an explicit cast or assign it to a variable of the correct type.
e.g.
#include <ostream>
int main()
{
// This statement has no effect:
static_cast<std::ostream&(*)(std::ostream&)>( std::endl );
std::ostream&(*fp)(std::ostream&) = std::endl;
}
Usually, you just use it in a context where the template argument is deduced automatically.
#include <iostream>
#include <ostream>
int main()
{
std::cout << std::endl;
std::endl( std::cout );
}