Using namespace std c ошибка

Compiler Error C2065

‘identifier‘ : undeclared identifier

The compiler can’t find the declaration for an identifier. There are many possible causes for this error. The most common causes of C2065 are that the identifier hasn’t been declared, the identifier is misspelled, the header where the identifier is declared isn’t included in the file, or the identifier is missing a scope qualifier, for example, cout instead of std::cout. For more information on declarations in C++, see Declarations and Definitions (C++).

Here are some common issues and solutions in greater detail.

The identifier is undeclared

If the identifier is a variable or a function name, you must declare it before it can be used. A function declaration must also include the types of its parameters before the function can be used. If the variable is declared using auto, the compiler must be able to infer the type from its initializer.

If the identifier is a member of a class or struct, or declared in a namespace, it must be qualified by the class or struct name, or the namespace name, when used outside the struct, class, or namespace scope. Alternatively, the namespace must be brought into scope by a using directive such as using namespace std;, or the member name must be brought into scope by a using declaration, such as using std::string;. Otherwise, the unqualified name is considered to be an undeclared identifier in the current scope.

If the identifier is the tag for a user-defined type, for example, a class or struct, the type of the tag must be declared before it can be used. For example, the declaration struct SomeStruct { /*...*/ }; must exist before you can declare a variable SomeStruct myStruct; in your code.

If the identifier is a type alias, the type must be declared by a using declaration or typedef before it can be used. For example, you must declare using my_flags = std::ios_base::fmtflags; before you can use my_flags as a type alias for std::ios_base::fmtflags.

Example: misspelled identifier

This error commonly occurs when the identifier name is misspelled, or the identifier uses the wrong uppercase and lowercase letters. The name in the declaration must exactly match the name you use.

// C2065_spell.cpp
// compile with: cl /EHsc C2065_spell.cpp
#include <iostream>
using namespace std;
int main() {
    int someIdentifier = 42;
    cout << "Some Identifier: " << SomeIdentifier << endl;
    // C2065: 'SomeIdentifier': undeclared identifier
    // To fix, correct the spelling:
    // cout << "Some Identifier: " << someIdentifier << endl;
}

Example: use an unscoped identifier

This error can occur if your identifier isn’t properly scoped. If you see C2065 when you use cout, a scope issue is the cause. When C++ Standard Library functions and operators aren’t fully qualified by namespace, or you haven’t brought the std namespace into the current scope by using a using directive, the compiler can’t find them. To fix this issue, you must either fully qualify the identifier names, or specify the namespace with the using directive.

This example fails to compile because cout and endl are defined in the std namespace:

// C2065_scope.cpp
// compile with: cl /EHsc C2065_scope.cpp
#include <iostream>
// using namespace std;   // Uncomment this line to fix

int main() {
    cout << "Hello" << endl;   // C2065 'cout': undeclared identifier
                               // C2065 'endl': undeclared identifier
    // Or try the following line instead
    std::cout << "Hello" << std::endl;
}

Identifiers that are declared inside of class, struct, or enum class types must also be qualified by the name of their enclosing scope when you use them outside of that scope.

Example: precompiled header isn’t first

This error can occur if you put any preprocessor directives, such as #include, #define, or #pragma, before the #include of a precompiled header file. If your source file uses a precompiled header file (that is, if it’s compiled by using the /Yu compiler option) then all preprocessor directives before the precompiled header file are ignored.

This example fails to compile because cout and endl are defined in the <iostream> header, which is ignored because it’s included before the precompiled header file. To build this example, create all three files, then compile pch.h (some versions of Visual Studio use stdafx.cpp), then compile C2065_pch.cpp.

// pch.h (stdafx.h in Visual Studio 2017 and earlier)
#include <stdio.h>

The pch.h or stdafx.h source file:

// pch.cpp (stdafx.cpp in Visual Studio 2017 and earlier)
// Compile by using: cl /EHsc /W4 /c /Ycstdafx.h stdafx.cpp
#include "pch.h"

Source file C2065_pch.cpp:

// C2065_pch.cpp
// compile with: cl /EHsc /W4 /Yustdafx.h C2065_pch.cpp
#include <iostream>
#include "stdafx.h"
using namespace std;

int main() {
    cout << "Hello" << endl;   // C2065 'cout': undeclared identifier
                               // C2065 'endl': undeclared identifier
}

To fix this issue, add the #include of <iostream> into the precompiled header file, or move it after the precompiled header file is included in your source file.

Example: missing header file

The error can occur if you haven’t included the header file that declares the identifier. Make sure the file that contains the declaration for the identifier is included in every source file that uses it.

// C2065_header.cpp
// compile with: cl /EHsc C2065_header.cpp

//#include <stdio.h>
int main() {
    fpos_t file_position = 42; // C2065: 'fpos_t': undeclared identifier
    // To fix, uncomment the #include <stdio.h> line
    // to include the header where fpos_t is defined
}

Another possible cause is if you use an initializer list without including the <initializer_list> header.

// C2065_initializer.cpp
// compile with: cl /EHsc C2065_initializer.cpp

// #include <initializer_list>
int main() {
    for (auto strList : {"hello", "world"})
        if (strList == "hello") // C2065: 'strList': undeclared identifier
            return 1;
    // To fix, uncomment the #include <initializer_list> line
}

You may see this error in Windows Desktop app source files if you define VC_EXTRALEAN, WIN32_LEAN_AND_MEAN, or WIN32_EXTRA_LEAN. These preprocessor macros exclude some header files from windows.h and afxv_w32.h to speed compiles. Look in windows.h and afxv_w32.h for an up-to-date description of what’s excluded.

Example: missing closing quote

This error can occur if you’re missing a closing quote after a string constant. It’s an easy way to confuse the compiler. The missing closing quote may be several lines before the reported error location.

// C2065_quote.cpp
// compile with: cl /EHsc C2065_quote.cpp
#include <iostream>

int main() {
    // Fix this issue by adding the closing quote to "Aaaa"
    char * first = "Aaaa, * last = "Zeee";
    std::cout << "Name: " << first
        << " " << last << std::endl; // C2065: 'last': undeclared identifier
}

Example: use iterator outside for loop scope

This error can occur if you declare an iterator variable in a for loop, and then you try to use that iterator variable outside the scope of the for loop. The compiler enables the /Zc:forScope compiler option by default. For more information, see Debug iterator support.

// C2065_iter.cpp
// compile with: cl /EHsc C2065_iter.cpp
#include <iostream>
#include <string>

int main() {
    // char last = '!';
    std::string letters{ "ABCDEFGHIJKLMNOPQRSTUVWXYZ" };
    for (const char& c : letters) {
        if ('Q' == c) {
            std::cout << "Found Q!" << std::endl;
        }
        // last = c;
    }
    std::cout << "Last letter was " << c << std::endl; // C2065
    // Fix by using a variable declared in an outer scope.
    // Uncomment the lines that declare and use 'last' for an example.
    // std::cout << "Last letter was " << last << std::endl; // C2065
}

Example: preprocessor removed declaration

This error can occur if you refer to a function or variable that is in conditionally compiled code that isn’t compiled for your current configuration. The error can also occur if you call a function in a header file that currently isn’t supported in your build environment. If certain variables or functions are only available when a particular preprocessor macro is defined, make sure the code that calls those functions can only be compiled when the same preprocessor macro is defined. This issue is easy to spot in the IDE: The declaration for the function is greyed out if the required preprocessor macros aren’t defined for the current build configuration.

Here’s an example of code that works when you build in Debug, but not Release:

// C2065_defined.cpp
// Compile with: cl /EHsc /W4 /MT C2065_defined.cpp
#include <iostream>
#include <crtdbg.h>
#ifdef _DEBUG
    _CrtMemState oldstate;
#endif
int main() {
    _CrtMemDumpStatistics(&oldstate);
    std::cout << "Total count " << oldstate.lTotalCount; // C2065
    // Fix by guarding references the same way as the declaration:
    // #ifdef _DEBUG
    //    std::cout << "Total count " << oldstate.lTotalCount;
    // #endif
}

Example: C++/CLI type deduction failure

This error can occur when calling a generic function, if the intended type argument can’t be deduced from the parameters used. For more information, see Generic Functions (C++/CLI).

// C2065_b.cpp
// compile with: cl /clr C2065_b.cpp
generic <typename ItemType>
void G(int i) {}

int main() {
   // global generic function call
   G<T>(10);     // C2065
   G<int>(10);   // OK - fix with a specific type argument
}

Example: C++/CLI attribute parameters

This error can also be generated as a result of compiler conformance work that was done for Visual Studio 2005: parameter checking for Visual C++ attributes.

// C2065_attributes.cpp
// compile with: cl /c /clr C2065_attributes.cpp
[module(DLL, name=MyLibrary)];   // C2065
// try the following line instead
// [module(dll, name="MyLibrary")];

[export]
struct MyStruct {
   int i;
};

Допустим, вы впервые едете к другу, и вам дан адрес: Фронт-стрит, 245 в Милл-Сити. Достигнув Милл-Сити, вы открываете свою карту и обнаруживаете, что на самом деле в Милл-Сити есть две разные улицы Фронт-стрит, расположенные на разных концах города! Куда бы вы поехали? Если нет дополнительных подсказок, которые помогли бы вам принять решение (например, вы помните, что его дом находится у реки), вам придется позвонить своему другу и попросить дополнительную информацию. Поскольку это сбивает с толку и неэффективно (особенно для почтальона), в большинстве стран все названия улиц и адреса домов в городе должны быть уникальными.

Точно так же C++ требует, чтобы все идентификаторы были однозначными. Если два идентичных идентификатора вводятся в одну и ту же программу таким образом, что компилятор или компоновщик не может их различить, компилятор или компоновщик выдаст ошибку. Эта ошибка обычно называется конфликтом имен (или коллизией имен).

Пример коллизии имен

a.cpp:

#include <iostream>
 
void myFcn(int x)
{
    std::cout << x;
}

main.cpp:

#include <iostream>
 
void myFcn(int x)
{
    std::cout << 2 * x;
}
 
int main()
{
    return 0;
}

Когда компилятор компилирует эту программу, он независимо компилирует a.cpp и main.cpp, и каждый файл компилируется без проблем.

Однако, когда работает компоновщик, он слинкует все определения в a.cpp и main.cpp вместе и обнаружит конфликтующие определения для функции myFcn. После этого компоновщик прервет работу, выдав ошибку. Обратите внимание, что эта ошибка возникает, даже если myFcn никогда не вызывается!

Большинство конфликтов имен возникают в двух случаях:

1. Два (или более) определения функции (или глобальной переменной) вводятся в отдельные файлы, которые компилируются в одну программу. Это приведет к ошибке компоновщика, как показано выше.
2. Два (или более) определения функции (или глобальной переменной) вводятся в один и тот же файл (часто через #include). Это приведет к ошибке компилятора.

По мере того, как программы становятся больше и используют больше идентификаторов, вероятность возникновения конфликта имен значительно возрастает. Хорошей новостью является то, что C++ предоставляет множество механизмов для предотвращения конфликтов имен. Одним из таких механизмов является локальная область видимости, которая не позволяет локальным переменным, определенным внутри функций, конфликтовать друг с другом. Но локальная область видимости не работает для имен функций. Так как же нам уберечь имена функций от конфликта друг с другом?

Что такое пространство имен?

Вернемся на мгновение к нашей аналогии с адресом: наличие двух Фронт-стрит было проблемой только потому, что эти улицы существовали в одном городе. С другой стороны, если бы вам пришлось доставлять почту по двум адресам: один на Фронт-стрит, 209 в Милл-Сити, а другой – на Фронт-стрит, 417 в Джонсвилле, путаницы в том, куда идти, не возникнет. Другими словами, города предоставляют группы, которые позволяют нам устранять неоднозначность адресов, которые в противном случае могли бы конфликтовать друг с другом. Пространства имен действуют так же, как города в этой аналогии.

Пространство имен – это область, которая позволяет вам объявлять имена внутри него с целью устранения неоднозначности. Пространство имен обеспечивает область видимости (называемую областью пространства имен) для имен, объявленных внутри него, что просто означает, что любое имя, объявленное внутри пространства имен, не будет ошибочно принято за идентичные имена в других областях видимости.

В пространстве имен все имена должны быть уникальными, в противном случае возникнет конфликт имен.

Пространства имен часто используются для группировки в большом проекте связанных идентификаторов, чтобы избежать непреднамеренного конфликта с другими идентификаторами. Например, если вы поместите все свои математические функции в пространство имен, называемое math, тогда ваши математические функции не будут конфликтовать с функциями с такими же именами вне пространства имен math.

На следующем уроке мы поговорим о том, как создавать собственные пространства имен.

Глобальное пространство имен

В C++ любое имя, которое не определено внутри класса, функции или пространства имен, считается частью неявно определенного пространства имен, называемого глобальным пространством имен (иногда также называемым глобальной областью видимости).

В примере в начале урока функции main() и обе версии myFcn() определены внутри глобального пространства имен. Конфликт имен, обнаруженный в этом примере, происходит из-за того, что обе версии myFcn() попадают в глобальное пространство имен, что нарушает правило, согласно которому все имена в пространстве имен должны быть уникальными.

Когда C++ был только разработан, все идентификаторы в стандартной библиотеке C++ (включая std::cin и std::cout) были доступны для использования без префикса std:: (они были частью глобального пространства имен). Однако это означало, что любой идентификатор в стандартной библиотеке потенциально может конфликтовать с любым именем, которое вы выбрали для своих собственных идентификаторов (также определенных в глобальном пространстве имен). Код, который работал, мог внезапно получить конфликт имен, когда вы включили через #include новый файл из стандартной библиотеки. Или, что еще хуже, программы, которые будут компилироваться под одной версией C++, могут не компилироваться под будущей версией C++, поскольку новые идентификаторы, введенные в стандартную библиотеку, могут иметь конфликт имен с уже написанным кодом. Таким образом, C++ переместил все функции стандартной библиотеки в пространство имен с именем std (сокращение от «standard», «стандарт»).

Оказывается, имя std::cout на самом деле не std::cout. На самом деле это просто cout, а std – это имя пространства имен, частью которого является идентификатор cout. Поскольку cout определен в пространстве имен std, имя cout не будет конфликтовать с любыми объектами или функциями с именем cout, которые мы создаем в глобальном пространстве имен.

Точно так же при доступе к идентификатору, который определен в пространстве имен (например, std::cout), вам необходимо сообщить компилятору, что мы ищем идентификатор, определенный внутри пространства имен (std).

Есть несколько способов сделать это.

Явный квалификатор пространства имен std::

Самый простой способ сообщить компилятору, что мы хотим использовать cout из пространства имен std, – это явно использовать префикс std::. Например:

#include <iostream>
 
int main()
{
    // когда мы говорим cout, мы имеем в виду cout, определенный в пространстве имен std
    std::cout << "Hello world!";
    return 0;
}

Символы :: – это оператор, называемый оператором разрешения области видимости. Идентификатор слева от символов :: определяет пространство имен, в котором содержится имя справа от символов ::. Если идентификатор слева от символа :: не указан, предполагается глобальное пространство имен.

Поэтому, когда мы говорим std::cout, мы говорим «cout, который находится в пространстве имен std».

Это самый безопасный способ использования cout, потому что нет двусмысленности в том, на какой cout мы ссылаемся (на тот, который находится в пространстве имен std).

using namespace std (и почему его следует избегать)

Другой способ получить доступ к идентификаторам внутри пространства имен – использовать инструкцию директивы using. Вот наша исходная программа HelloWorld с директивой using:

#include <iostream>

// это директива using, указывающая компилятору проверять пространство имен std
// при разрешении идентификаторов без префикса 
using namespace std;
 
int main()
{
    // cout не имеет префикса, поэтому компилятор проверит, 
    // определен ли cout локально или в пространстве имен std
    cout << "Hello world!";
    return 0;
}

Директива using указывает компилятору проверять указанное пространство имен при попытке разрешить идентификатор, не имеющий префикса пространства имен. Итак, в приведенном выше примере, когда компилятор определяет, что такое идентификатор cout, он проверяет как локально (где он не определен), так и в пространстве имен std (где он будет соответствовать std::cout).

Многие тексты, руководства и даже некоторые компиляторы рекомендуют или используют директиву using в верхней части программы. Однако при таком использовании это плохая практика, и она крайне не рекомендуется.

Рассмотрим следующую программу:

#include <iostream> // импортирует объявление std::cout
 
using namespace std; // делает std::cout доступным как "cout"
 
int cout() // объявляет нашу собственную функцию "cout"
{
    return 5;
}
 
int main()
{
    cout << "Hello, world!"; // Ошибка компиляции! Какой cout нам здесь нужен? 
                             // Тот, который находится в пространстве имен std или тот,
                             // который мы определили выше?
 
    return 0;
}

Приведенная выше программа не компилируется, потому что теперь компилятор не может определить, нужна нам функция cout, которую мы определили, или cout, которая определена внутри пространства имен std.

При использовании директивы using таким образом любой идентификатор, который мы определяем, может конфликтовать с любым идентификатором с таким же именем в пространстве имен std. Хуже того, хотя имя идентификатора может не конфликтовать сегодня, оно может конфликтовать с новыми идентификаторами, добавленными в пространство имен std в будущих версиях языка. В этом изначально и заключалась вся суть перемещения всех идентификаторов стандартной библиотеки в пространство имен std!

Подробнее об инструкциях using (и соответственно о том, как их использовать) мы поговорим в уроке «6.12 – Инструкции using».

Теги

C++ / CppLearnCppДля начинающихКомпиляторЛинкерОбучениеПрограммированиеПространство имен