-->![Namespace Namespace](/uploads/1/3/3/8/133896116/607045773.png)
Figure 12.
Feb 27, 2019 Dev Lifestyle; Why “using namespace std” is used after including iostream. First of all, you need to know what c namespaces are. In programming, we cannot have variables, functions, etc. Namespaces (C) A namespace is a declarative region that provides a scope to the identifiers (the names of types, functions, variables, etc) inside it. Namespaces are used to organize code into logical groups and to prevent name collisions that can occur especially when your code base includes multiple libraries. Creating and Using Namespace in C Namespace is a container for identifiers. It puts the names of its members in a distinct space so that they don't conflict with the names in other namespaces or global namespace. You can do that from the UI by right clicking on your project and choosing 'References'. From there you can add a new reference for.NET. Alternatively you can reference the DLL directly from your code with a #using statement: #using using namespace System; int main Console::WriteLine ( 'Hello, world!'
Download david cook fade into me meme. A namespace is a declarative region that provides a scope to the identifiers (the names of types, functions, variables, etc) inside it. Namespaces are used to organize code into logical groups and to prevent name collisions that can occur especially when your code base includes multiple libraries. All identifiers at namespace scope are visible to one another without qualification. Identifiers outside the namespace can access the members by using the fully qualified name for each identifier, for example
std::vector<std::string> vec;
, or else by a using Declaration for a single identifier (using std::string
), or a using Directive for all the identifiers in the namespace (using namespace std;
). Code in header files should always use the fully qualified namespace name.The following example shows a namespace declaration and three ways that code outside the namespace can accesses their members.
Use the fully qualified name:
Use a using declaration to bring one identifier into scope:
Use a using directive to bring everything in the namespace into scope:
using directives
The using directive allows all the names in a namespace to be used without the namespace-name as an explicit qualifier. Use a using directive in an implementation file (i.e. *.cpp) if you are using several different identifiers in a namespace; if you are just using one or two identifiers, then consider a using declaration to only bring those identifiers into scope and not all the identifiers in the namespace. If a local variable has the same name as a namespace variable, the namespace variable is hidden. It is an error to have a namespace variable with the same name as a global variable.
Note
A using directive can be placed at the top of a .cpp file (at file scope), or inside a class or function definition.
In general, avoid putting using directives in header files (*.h) because any file that includes that header will bring everything in the namespace into scope, which can cause name hiding and name collision problems that are very difficult to debug. Always use fully qualified names in a header file. If those names get too long, you can use a namespace alias to shorten them. (See below.)
Declaring namespaces and namespace members
Typically, you declare a namespace in a header file. Real guitar 2 vst download. If your function implementations are in a separate file, then qualify the function names, as in this example.
Function implementations in contosodata.cpp should use the fully qualified name, even if you place a using directive at the top of the file:
A namespace can be declared in multiple blocks in a single file, and in multiple files. The compiler joins the parts together during preprocessing and the resulting namespace contains all the members declared in all the parts. An example of this is the std namespace which is declared in each of the header files in the standard library.
Members of a named namespace can be defined outside the namespace in which they are declared by explicit qualification of the name being defined. However, the definition must appear after the point of declaration in a namespace that encloses the declaration's namespace. For example:
This error can occur when namespace members are declared across multiple header files, and you have not included those headers in the correct order.
The global namespace
If an identifier is not declared in an explicit namespace, it is part of the implicit global namespace. In general, try to avoid making declarations at global scope when possible, except for the entry point main Function, which is required to be in the global namespace. To explicitly qualify a global identifier, use the scope resolution operator with no name, as in
::SomeFunction(x);
. This will differentiate the identifier from anything with the same name in any other namespace, and it will also help to make your code easier for others to understand.The std namespace
All C++ standard library types and functions are declared in the
std
namespace or namespaces nested inside std
.Nested namespaces
Namespaces may be nested. An ordinary nested namespace has unqualified access to its parent's members, but the parent members do not have unqualified access to the nested namespace (unless it is declared as inline), as shown in the following example:
Ordinary nested namespaces can be used to encapsulate internal implementation details that are not part of the public interface of the parent namespace.
![Namespace Namespace](/uploads/1/3/3/8/133896116/607045773.png)
Inline namespaces (C++ 11)
In contrast to an ordinary nested namespace, members of an inline namespace are treated as members of the parent namespace. This characteristic enables argument dependent lookup on overloaded functions to work on functions that have overloads in a parent and a nested inline namespace. It also enables you to declare a specialization in a parent namespace for a template that is declared in the inline namespace. The following example shows how external code binds to the inline namespace by default:
The following example shows how you can declare a specialization in a parent of a template that is declared in an inline namespace:
You can use inline namespaces as a versioning mechanism to manage changes to the public interface of a library. For example, you can create a single parent namespace, and encapsulate each version of the interface in its own namespace nested inside the parent. The namespace that holds the most recent or preferred version is qualified as inline, and is therefore exposed as if it were a direct member of the parent namespace. Client code that invokes the Parent::Class will automatically bind to the new code. Clients that prefer to use the older version can still access it by using the fully qualified path to the nested namespace that has that code.
The inline keyword must be applied to the first declaration of the namespace in a compilation unit.
The following example shows two versions of an interface, each in a nested namespace. The
v_20
namespace has some modification from the v_10
interface and is marked as inline. Client code that uses the new library and calls Contoso::Funcs::Add
will invoke the v_20 version. Code that attempts to call Contoso::Funcs::Divide
will now get a compile time error. If they really need that function, they can still access the v_10
version by explicitly calling Contoso::v_10::Funcs::Divide
.Namespace aliases
Namespace names need to be unique, which means that often they should not be too short. If the length of a name makes code difficult to read, or is tedious to type in a header file where using directives can't be used, then you can make a namespace alias which serves as an abbreviation for the actual name. For example:
anonymous or unnamed namespaces
You can create an explicit namespace but not give it a name:
This is called an unnamed or anonymous namespace and it is useful when you want to make variable declarations invisible to code in other files (i.e. give them internal linkage) without having to create a named namespace. All code in the same file can see the identifiers in an unnamed namespace but the identifiers, along with the namespace itself, are not visible outside that file—or more precisely outside the translation unit.
See also
Creating a C++ application using the Standard Template Library and the CDT
This article, which is a follow-up to 'C/C++ development with the Eclipse Platform,' is intended for C++ developers who want to learn C++ development using the Eclipse CDT. A simple C++ application is developed in the article. The application makes use of the C++ STL. Readers should be familiar with the STL, as well as with basic object-oriented programming principles such as inheritance and polymorphism. A familiarity with Eclipse will be helpful, but is not required.
Before we start
You need to install the following:
- EclipseWe're using the CDT, which is a plug-in to Eclipse, so of course you need Eclipse. The article uses Eclipse V3.2.
- Java Runtime EnvironmentWe're building a C++ application, but we're using Eclipse. Eclipse is a Java application itself, so it needs a Java Runtime Environment (JRE). The article uses Eclipse V3.2, which requires a JRE of V1.4 or higher. If you want to also use Eclipse for Java development, you'll need a Java Development Kit (JDK).
- Eclipse C/C++ Development Toolkit (CDT)This article is about the CDT, so you'll need it, of course. For instructions on installing the CDT on early versions of Eclipse, read a 'C/C++ Development with the Eclipse Platform' (developerWorks 2003) .
- CygwinIf you're using Microsoft Windows®, you will find Cygwin — which provides a Linux®-like environment on Windows — helpful.
- GNU C/C++ Development ToolsThe CDT uses the standard GNU C/C++ tools for compiling your code, building your project, and debugging the applications. These tools are GNU Compiler Collection (GCC) for C++ (g++), make, and the GNU Project Debugger (GDB). If you're a programmer using Linux or Mac OS X, there's a pretty good chance these tools are installed on your machine. The article contains instructions for setting up these tools for Windows.
The Eclipse CDT
The Eclipse CDT is an Eclipse plug-in that transforms Eclipse into a powerful C/C++ IDE. It was designed to bring many of the great features Eclipse enjoyed by Java developers to C/C++ developers, such as project management, integrated debugging, class wizards, automated builds, syntax coloring, and code completion. When Eclipse is used as a Java IDE, it leverages and integrates with the JDK. Similarly, the CDT leverages and integrates with standard C/C++ tools, such as g++, make, and GDB. This has lead to it becoming very popular on Linux, where those tools are readily available and used for most C++ development. The CDT can be set up on Windows to use the same tools. There is also an ongoing effort to get the CDT to work with Microsoft's C++ tools to make it even more attractive to Windows C++ developers.
Installing the CDT
We start by assuming you installed Eclipse and can run it. If not, consult Eclipse's Web site for getting up and running. Let's install the CDT. The CDT is an Eclipse plug-in, so it uses Eclipse's Software Updates feature. Select Help > Software Updates > Find and Install.
Figure 1. Eclipse Software Updates
Next, you'll want to choose Search for new features to install.
Figure 2. Search for new features
If you're using a newer version of Eclipse, the Callisto or Europa discovery sites should be included. (Editor's note: Since this was written in April 2007, the Europa release was still in the planning stages. However, installing Europa is expected to be similar to Callisto.) Simply select it and click Finish.
Figure 3. Callisto Discovery Site
Eclipse might ask you to choose from a list of mirror sites for the Callisto Discovery Site. Pick whatever one seems closest to you. You should see a list of plug-ins from the Callisto Discovery Site. You'll want to select C and C++ Development and click Next.
Figure 4. Available Callisto plug-ins
You'll be asked to accept the license for the CDT. Once you've done that, you can click Next. You'll see a summary of what's going to be downloaded and installed. Simply click Finish.
Figure 5. Download and installation summary
Eclipse's Update Manager will then download the CDT plug-in from the mirror site you selected earlier. The CDT is about 11 MB total, so this could take a few minutes, depending on your Internet connection speed. Once everything is downloaded, you'll be asked to confirm that you want to install the new features. Click Install All.
Figure 6. Confirm installation
After you finish installing CDT, you'll be asked to restart Eclipse. Go ahead and do that. Once Eclipse restarts, the CDT will be ready to go.
Windows configuration
If you're running Eclipse on Linux or Mac OS X, you're ready to start using the CDT to develop a C++ application. If you're on Windows, there might be a few more steps. As mentioned, CDT relies on the standard GNU C++ development tools: g++, make, and GDB. These are usually included on Linux or Mac OS X. They're usually not included with Windows. But don't worry. These tools can be easily installed on Windows. Perhaps the easiest way is to install Cygwin. Cygwin provides Linux-like environment on Windows (see Related topics). When installing Cygwin, you'll be asked to pick the packages you want to install. Make sure to go into the development section and select gcc: g++, make, and GDB. This will cause their prerequisites to be installed, too.
Once you're done installing Cygwin, you'll need to add g++, make, and GDB to your path. The easiest way to do this is to add Cygwin's bin directory to your path, since that's where g++, make, and GDB can be found. Once that's done, restart Eclipse.
Playing the lottery
At this point, we should be ready to start developing our application with CDT. Let's pause to figure out what we want to develop. The sample application is a simple command-line program for generating lottery numbers. Many states have lotteries, and the rules vary quite a bit. We'll allow the user to pick which state lottery he wants to generate numbers for. This will provide us a good way to use C++'s support for polymorphic behavior.
Creating the project
Eclipse uses the concepts of perspectives to allow for various plug-ins to customize their commands and views. Eclipse starts off by default in the Java perspective. CDT includes its own perspective, so we'll want to switch to that. To do that, select Window > Open Perspective > Other. You should see a list of perspectives available to you. Select the C/C++ perspective and click OK.
Figure 7. Select C/C++ perspective
Eclipse should now look something like Figure 8.
Figure 8. The C/C++ perspective
Eclipse organizes your code into projects, so we'll want to create a new project. Select File > New > Managed Make C++ Project.
Figure 9. New C++ project
You might have noticed there were several different options for the project. We wanted a C++ project. We selected a 'Managed Make,' since that will allow Eclipse to create the make file for us. You could select a 'Standard Make' flavor and write your own make file. We should now be in the New Project wizard, where we'll name our project Lottery and click Finish.
This will create an empty project, which you should see in the C/C++ Projects window. Right-click on the project and select New > Source Folder. This will bring up the 'New Source Folder' wizard, where we'll name our folder src and click Finish.
Basic lottery
We're ready to start creating some code. We'll start by creating the executable of our application. Right-click on the source folder we just created and selected New > Source File, as shown in Figure 10.
Let's create an empty main method for now. This is just a placeholder; we'll add more to this after we've created the rest of our project.
Save your project, and Eclipse will make it for you automatically. You should see some output in the console indicating that it compiled successfully.
We're ready to create our first class. Right-click on the source folder we just created and select New > Class.
Figure 10. New class
This should bring up the New Class wizard. We'll give our class a namespace lotto, and we'll call our class Lottery.
Figure 11. Lottery class
Eclipse will now create stubs for your class. CDT does a lot of nice things for you. It generates the appropriate compiler directives in the header file. It encourages best practices by generating separate interface (Lottery.h) and implementation (Lottery.cpp) files. It encourages another best practice by making your class' destructor virtual. We can enter the source code for these classes as seen in Listings 1 and 2.
Listing 1. Lottery.h
Listing 2 shows the implementation file for the
Lottery
class.Listing 2. Lottery.cpp
Using Namespace System
What's this code doing? Well, our
Lottery
class has two attributes. The ticketSize
attribute is the number of numbers on the lottery ticket. The maxNum
is the maximum number on the ticket. Later, we'll use the Florida state lottery as an example. There, you pick six numbers from 1 to 53, so ticketSize
would be 6 and maxNum
would be 53.The
generateNumbers
method generates an array of numbers corresponding to the numbers on a lottery ticket. It uses the STL function rand()
to generate numbers randomly. The allNums
array is used to keep track of what numbers have been generated so far, so we can make sure we don't get a duplicate number on our ticket. Finally, the printTicket()
creates a string representation of our ticket.When you save the files, Eclipse builds your project automatically. Again, if you save the project, it should be compiled and you should see compilation messages in the console, as shown in Listing 3.
Listing 3. Compiler output in console
MegaLottery
class
You might have noticed that we made the
printTicket()
method virtual when it was declared in the header file. That will allow us to subclass Lottery
and override this method. We wanted to do that because some states have a lottery with a 'mega' number. This is a separately drawn number that any ticket must match in addition to the other numbers drawn. Let's create a MegaLottery
class for these states that will subclass Lottery
.Once again, right-click on our source folder and select New > Class, as we did earlier. This time in the New Class wizard, we'll declare our new class in the same namespace, but call it
MegaLottery
.Figure 12. MegaLottery
class
To subclass
Lottery
, select the Add button next to the Base Classes section. This will bring up the Choose Base Class dialog. You can start typing the name of the class, and Eclipse will narrow the list of base class candidates quickly. You'll want to select Lottery and click OK.Figure 13. Choose base classes
We can enter the code for
MegaLottery
, as shown in Listings 4 and 5.Listing 4. MegaLottery.h
Listing 5 shows the implementation file for the
MegaLottery
class.Listing 5. MegaLottery.cpp
The main difference between
Lottery
and MegaLottery
is that MegaLottery
has an extra attribute maxMegaNum
. This is the max value that the mega number can take. It overrides the printTicket()
method. It uses the base class to generate the first part of the ticket, then it generates the mega number and appends it to the string representation of the ticket.We just need a way to create the various lotteries. We'll use a class
Factory Pattern
to do this. We'll do this by adding a LotteryFactory
class. We want all Lotteries
to come from the same factory, so we'll make LotteryFactory
a singleton. The code for it is in Listings 6 and 7.Listing 6. #ifndef LOTTERYFACTORY_H_
Listing 7 shows the implementation file for the
LotteryFactory
class.Listing 7. LotteryFactory.cpp
The
LotteryFactory
has an enum of the different types of lotteries. We've only put in Florida and California in the example, but it shouldn't be hard to add as many as you want. The LotteryFactory
's constructor seeds the rand()
function used by our lottery classes. We just need to implement our executable's main method.Listing 8. Main.cpp
Running the program
We're ready to run our program. Select Run > Run.
Figure 14. Choose base classes
Select C/C++ Local Application and click the New button.
Figure 15. New C/C++ run profile
This will bring up the Create run configuration interface for the Lottery project. You'll need to select its executable by clicking the Search Project button.
Figure 16. Search project for executable
You can select the binary that Eclipse created for you and click OK.
Figure 17. Search project for executable
Just click Run, and the program should run in your console. The code below shows some sample output.
Debugging the program
Our program should run fine, but let's take a look at debugging the application. First, create a breakpoint in our code. Pick a line and right-click next to it and select Toggle Breakpoint.
Figure 18. Create breakpoint
We need to create a debug configuration, much like we created a run configuration. Select Run > Debug.
Figure 19. Create debug configuration
This should bring up the Debug configuration. This is based on the Run configuration, and you shouldn't need to change anything. Just click Debug.
Figure 20. Debug configuration
Once the debugger starts, it will prompt you to switch to the Debugger perspective. Do so. Notice that in the configuration we set things to break automatically at the startup of our main method. Thus, the debugger should break immediately and you should see a screen something like Figure 21.
C++ Using Namespace Functions
Figure 21. The debugger
Summary
We've built and debugged our lottery application. You can easily add more lottery schemes to it. Some of these could involve additional subclasses. CDT makes it easier than ever to create these classes and class hierarchies, and to run and debug the application to test it.
Downloadable resources
Related topics
- Integrate an external code checker into Eclipse CDT (Alex Ruiz, developerWorks): Learn how to execute C/C++ code analysis tools with Codan in Eclipse.
- Get an overview of the CDT in 'C/C++ development with the Eclipse Platform.'
- Dig deep into the CDT's architecture in the five-part series titled 'Building a CDT-based editor.'
- As someone interested in C/C++ development, you might want to check out a trial of IBM's XL C/C++ compiler for Linux or AIX®.
- Windows developers can learn about migrating to the CDT in 'Migrate Visual Studio C and C++ projects to Eclipse CDT.'
- Windows developers can also check out the CDT-MSVC project, a project for incorporating Microsoft's compiler and debugger with CDT.
- Learn about MinGW, the GNU C/C++ tools for Windows included with Cygwin.
- Download Cygwin a Linux-like environment for Windows. It consists of two parts: A DLL that acts as a Linux API emulation layer providing substantial Linux API functionality and a collection of tools that provide a Linux look and feel.
- The Eclipse C/C++ Development Toolkit (CDT) download information contains the latest information about the available versions of CDT.
- Check out the 'Recommended Eclipse reading list.'
- For an introduction to the Eclipse platform, see 'Getting started with the Eclipse Platform.'