C++ Primer, Fifth Edition
namespace mathLib {
namespace MatrixLib {
class matrix { /* ... */ };
matrix operator*
(const matrix &, const matrix &);
// ...
How would you declare this operator in global scope?
18.2.2. Using Namespace Members
Referring to namespace members as namespace_name::member_name is
admittedly cumbersome, especially if the namespace name is long. Fortunately, there
are ways to make it easier to use namespace members. Our programs have used one
of these ways, using declarations (§ 3.1, p. 82). The others, namespace aliases and
using directives, will be described in this section.
Namespace Aliases
namespace alias can be used to associate a shorter synonym with a namespace
name. For example, a long namespace name such as
Click here to view code image
namespace cplusplus_primer      { /* ... */ };
can be associated with a shorter synonym as follows:
namespace primer = cplusplus_primer;
A namespace alias declaration begins with the keyword namespace, followed by the
alias name, followed by the = sign, followed by the original namespace name and a
semicolon. It is an error if the original namespace name has not already been defined
as a namespace.
A namespace alias can also refer to a nested namespace:
Click here to view code image
namespace Qlib = cplusplus_primer::QueryLib;
Qlib::Query q;
A namespace can have many synonyms, or aliases. All the aliases and the
original namespace name can be used interchangeably.
Pdf to powerpoint - C# Create PDF from PowerPoint Library to convert pptx, ppt to PDF in C#.net, ASP.NET MVC, WinForms, WPF
Online C# Tutorial for Creating PDF from Microsoft PowerPoint Presentation
converting pdf to ppt; how to convert pdf file to powerpoint presentation
Pdf to powerpoint - VB.NET Create PDF from PowerPoint Library to convert pptx, ppt to PDF in vb.net, ASP.NET MVC, WinForms, WPF
VB.NET Tutorial for Export PDF file from Microsoft Office PowerPoint
convert pdf into powerpoint online; conversion of pdf into ppt
C++ Primer, Fifth Edition
Declarations: A Recap
using declaration introduces only one namespace member at a time. It allows us
to be very specific regarding which names are used in our programs.
Names introduced in a using declaration obey normal scope rules: They are visible
from the point of the using declaration to the end of the scope in which the
declaration appears. Entities with the same name defined in an outer scope are
hidden. The unqualified name may be used only within the scope in which it is
declared and in scopes nested within that scope. Once the scope ends, the fully
qualified name must be used.
A using declaration can appear in global, local, namespace, or class scope. In class
scope, such declarations may only refer to a base class member (§ 15.5, p. 615).
using directive, like a using declaration, allows us to use the unqualified form of
a namespace name. Unlike a using declaration, we retain no control over which
names are made visible—they all are.
A using directive begins with the keyword using, followed by the keyword
namespace, followed by a namespace name. It is an error if the name is not a
previously defined namespace name. A using directive may appear in global, local, or
namespace scope. It may not appear in a class scope.
These directives make all the names from a specific namespace visible without
qualification. The short form names can be used from the point of the using directive
to the end of the scope in which the using directive appears.
Providing a using directive for namespaces, such as std, that our
application does not control reintroduces all the name collision problems
inherent in using multiple libraries.
Directives and Scope
The scope of names introduced by a using directive is more complicated than the
scope of names in using declarations. As we’ve seen, a using declaration puts the
name in the same scope as that of the using declaration itself. It is as if the using
Online Convert PowerPoint to PDF file. Best free online export
Online Powerpoint to PDF Converter. Download Free Trial. Then just wait until the conversion from Powerpoint to PDF is complete and download the file.
convert pdf document to powerpoint; convert pdf file to powerpoint presentation
RasterEdge XDoc.PowerPoint for .NET - SDK for PowerPoint Document
Able to view and edit PowerPoint rapidly. Convert. Convert PowerPoint to PDF. Convert PowerPoint to HTML5. Convert PowerPoint to Tiff. Convert PowerPoint to Jpeg
how to add pdf to powerpoint; pdf to ppt converter online for large
C++ Primer, Fifth Edition
declaration declares a local alias for the namespace member.
A using directive does not declare local aliases. Rather, it has the effect of lifting
the namespace members into the nearest scope that contains both the namespace
itself and the using directive.
This difference in scope between a using declaration and a using directive stems
directly from how these two facilities work. In the case of a using declaration, we
are simply making name directly accessible in the local scope. In contrast, a using
directive makes the entire contents of a namespace available In general, a namespace
might include definitions that cannot appear in a local scope. As a consequence, a
using directive is treated as if it appeared in the nearest enclosing namespace scope.
In the simplest case, assume we have a namespace A and a function f, both
defined at global scope. If f has a using directive for A, then in f it will be as if the
names in A appeared in the global scope prior to the definition of f:
Click here to view code image
// namespace A and function f are defined at global scope
namespace A {
int i, j;
void f()
using namespace A;     // injects the names from A into the global
cout << i *  j << endl; // uses i and j from namespace A
// ...
Directives Example
Let’s look at an example:
Click here to view code image
namespace blip {
int i = 16, j = 15, k = 23;
// other declarations
int j = 0; // ok: j inside blip is hidden inside a namespace
void manip()
// using directive; the names in blip are ''added'' to the global scope
using namespace blip; // clash between ::j and blip::j
// detected only if j is used
++i;        // sets blip::i to 17
++j;        // error ambiguous: global j or blip::j?
C# WinForms Viewer: Load, View, Convert, Annotate and Edit
C#: Create PDF from PowerPoint; C#: Create PDF from Tiff; C#: Convert PDF to Word; C#: Convert PDF to Tiff; Convert Microsoft Office PowerPoint to PDF (.pdf).
convert pdf slides to powerpoint; how to convert pdf to powerpoint
How to C#: Overview of Using XDoc.PowerPoint
How to C#: Overview of Using XDoc.PowerPoint. Overview for How to Use XDoc.PowerPoint in C# .NET Programming Project. PowerPoint Conversion.
convert pdf back to powerpoint; pdf conversion to powerpoint
C++ Primer, Fifth Edition
++::j;      // ok: sets global j to 1
++blip::j;  // ok: sets blip::j to 16
int k = 97; // local k hides blip::k
++k;        // sets local k to 98
The using directive in manip makes all the names in blip directly accessible;
code inside manip can refer to the names of these members, using their short form.
The members of blip appear as if they were defined in the scope in which both
blip and manip are defined. Assuming manip is defined at global scope, then the
members of blip appear as if they were declared in global scope.
When a namespace is injected into an enclosing scope, it is possible for names in
the namespace to conflict with other names defined in that (enclosing) scope. For
example, inside manip, the blip member j conflicts with the global object named j.
Such conflicts are permitted, but to use the name, we must explicitly indicate which
version is wanted. Any unqualified use of j within manip is ambiguous.
To use a name such as j, we must use the scope operator to indicate which name
is wanted. We would write ::j to obtain the variable defined in global scope. To use
the j defined in blip, we must use its qualified name, blip::j.
Because the names are in different scopes, local declarations within manip may
hide some of the namespace member names. The local variable k hides the
namespace member blip::k. Referring to k within manip is not ambiguous; it
refers to the local variable k.
Headers and 
Declarations or Directives
A header that has a using directive or declaration at its top-level scope injects
names into every file that includes the header. Ordinarily, headers should define only
the names that are part of its interface, not names used in its own implementation. As
a result, header files should not contain using directives or using declarations
except inside functions or namespaces (§ 3.1, p. 83).
Caution: Avoid using Directives
using directives, which inject all the names from a namespace, are deceptively
simple to use: With only a single statement, all the member names of a
namespace are suddenly visible. Although this approach may seem simple, it can
introduce its own problems. If an application uses many libraries, and if the
names within these libraries are made visible with using directives, then we are
back to square one, and the global namespace pollution problem reappears.
Moreover, it is possible that a working program will fail to compile when a new
version of the library is introduced. This problem can arise if a new version
introduces a name that conflicts with a name that the application is using.
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit PowerPoint
Such as load and view PowerPoint without Microsoft Office software installed, convert PowerPoint to PDF file, Tiff image and HTML file, as well as add
change pdf to ppt; pdf page to powerpoint
C# powerpoint - Convert PowerPoint to PDF in C#.NET
C# PowerPoint - Convert PowerPoint to PDF in C#.NET. Online C# Tutorial for Converting PowerPoint to PDF (.pdf) Document. PowerPoint to PDF Conversion Overview.
conversion of pdf into ppt; convert pdf to powerpoint
C++ Primer, Fifth Edition
Another problem is that ambiguity errors caused by using directives are
detected only at the point of use. This late detection means that conflicts can
arise long after introducing a particular library. If the program begins using a new
part of the library, previously undetected collisions may arise.
Rather than relying on a using directive, it is better to use a using
declaration for each namespace name used in the program. Doing so reduces the
number of names injected into the namespace. Ambiguity errors caused by
using declarations are detected at the point of declaration, not use, and so are
easier to find and fix.
One place where using directives are useful is in the implementation
files of the namespace itself.
Exercises Section 18.2.2
Exercise 18.15: Explain the differences between using declarations and
Exercise 18.16: Explain the following code assuming using declarations for
all the members of namespace Exercise are located at the location labeled
position 1.
What if they appear at 
position 2
instead? Now answer the same
question but replace the using declarations with a using directive for
namespace Exercise.
Click here to view code image
namespace Exercise {
int ivar = 0;
double dvar = 0;
const int limit = 1000;
int ivar = 0;
// position 1
void manip() {
// position 2
double dvar = 3.1416;
int iobj = limit + 1;
Exercise 18.17: Write code to test your answers to the previous question.
VB.NET PowerPoint: Read, Edit and Process PPTX File
How to convert PowerPoint to PDF, render PowerPoint to SVG, transform PowerPoint to TIFF and convert PowerPoint to raster images with featured rendering
add pdf to powerpoint presentation; online pdf converter to powerpoint
C# PDF Convert: How to Convert MS PPT to Adobe PDF Document
C#: Create PDF from PowerPoint; C#: Create PDF from Tiff; C#: Convert PDF to Word; C#: Convert PDF to Tiff; C# Tutorial: How to Convert PowerPoint to PDF.
how to add pdf to powerpoint presentation; changing pdf to powerpoint
C++ Primer, Fifth Edition
18.2.3. Classes, Namespaces, and Scope
Name lookup for names used inside a namespace follows the normal lookup rules: The
search looks outward through the enclosing scopes. An enclosing scope might be one
or more nested namespaces, ending in the all-encompassing global namespace. Only
names that have been declared before the point of use that are in blocks that are still
open are considered:
Click here to view code image
namespace A {
int i;
namespace B {
int i;         // hides A::i within B
int j;
int f1()
int j;    // j is local to f1 and hides A::B::j
return i; // returns B::i
 // namespace B is closed and names in it are no longer visible
int f2() {
return j;      // error: j is not defined
int j = i;        // initialized from A::i
When a class is wrapped in a namespace, the normal lookup still happens: When a
name is used by a member function, look for that name in the member first, then
within the class (including base classes), then look in the enclosing scopes, one or
more of which might be a namespace:
Click here to view code image
namespace A {
int i;
int k;
class C1 {
C1(): i(0), j(0) { }   // ok: initializes C1::i and C1::j
int f1() { return k; } // returns A::k
int f2() { return h; } // error: h is not defined
int f3();
int i;                 // hides A::i within C1
int j;
C++ Primer, Fifth Edition
int h = i;                 // initialized from A::i
// member f3 is defined outside class C1 and outside namespace A
int A::C1::f3() { return h; }  // ok: returns A::h
With the exception of member function definitions that appear inside the class body
(§ 7.4.1, p. 283), scopes are always searched upward; names must be declared
before they can be used. Hence, the return in f2 will not compile. It attempts to
reference the name h from namespace A, but h has not yet been defined. Had that
name been defined in A before the definition of C1, the use of h would be legal.
Similarly, the use of h inside f3 is okay, because f3 is defined after A::h.
The order in which scopes are examined to find a name can be inferred from
the qualified name of a function. The qualified name indicates, in reverse
order, the scopes that are searched.
The qualifiers A::C1::f3 indicate the reverse order in which the class scopes and
namespace scopes are to be searched. The first scope searched is that of the function
f3. Then the class scope of its enclosing class C1 is searched. The scope of the
namespace A is searched last before the scope containing the definition of f3 is
Argument-Dependent Lookup and Parameters of Class Type
Consider the following simple program:
std::string s;
std::cin >> s;
As we know, this call is equivalent to (§ 14.1, p. 553):
operator>>(std::cin, s);
This operator>> function is defined by the string library, which in turn is defined
in the std namespace. Yet we can we call operator>> without an std:: qualifier
and without a using declaration.
We can directly access the output operator because there is an important exception
to the rule that names defined in a namespace are hidden. When we pass an object of
a class type to a function, the compiler searches the namespace in which the
argument’s class is defined 
in addition
to the normal scope lookup. This exception also
applies for calls that pass pointers or references to a class type.
In this example, when the compiler sees the “call” to operator>>, it looks for a
C++ Primer, Fifth Edition
matching function in the current scope, including the scopes enclosing the output
statement. In addition, because the >> expression has parameters of class type, the
compiler also looks in the namespace(s) in which the types of cin and s are defined.
Thus, for this call, the compiler looks in the std namespace, which defines the
istream and string types. When it searches std, the compiler finds the string
output operator function.
This exception in the lookup rules allows nonmember functions that are conceptually
part of the interface to a class to be used without requiring a separate using
declaration. In the absence of this exception to the lookup rules, either we would have
to provide an appropriate using declaration for the output operator:
Click here to view code image
using std::operator>>;         // needed to allow cin >> s
or we would have to use the function-call notation in order to include the namespace
Click here to view code image
std::operator>>(std::cin, s); // ok: explicitly use std::>>
There would be no way to use operator syntax. Either of these declarations is
awkward and would make simple uses of the IO library more complicated.
Lookup and 
Many, perhaps even most, C++ programmers never have to think about argument-
dependent lookup. Ordinarily, if an application defines a name that is also defined in
the library, one of two things is true: Either normal overloading determines (correctly)
whether a particular call is intended for the application version or the one from the
library, or the application never intends to use the library function.
Now consider the library move and forward functions. Both of these functions are
template functions, and the library defines versions of them that have a single rvalue
reference function parameter. As we’ve seen, in a function template, an rvalue
reference parameter can match any type (§ 16.2.6, p. 690). If our application defines
a function named move that takes a single parameter, then—no matter what type the
parameter has—the application’s version of move will collide with the library version.
Similarly for forward.
As a result, name collisions with move (and forward) are more likely than
collisions with other library functions. In addition, because move and forward do
very specialized type manipulations, the chances that an application specifically wants
to override the behavior of these functions are pretty small.
The fact that collisions are more likely—and are less likely to be intentional—
explains why we suggest always using the fully qualified versions of these names (§
C++ Primer, Fifth Edition
12.1.5, p. 470). So long as we write std::move rather than move, we know that we
will get the version from the standard library.
Friend Declarations and Argument-Dependent Lookup
Recall that when a class declares a friend, the friend declaration does not make the
friend visible (§ 7.2.1, p. 270). However, an otherwise undeclared class or function
that is first named in a friend declaration is assumed to be a member of the closest
enclosing namespace. The combination of this rule and argument-dependent lookup
can lead to surprises:
Click here to view code image
namespace A {
class C {
// two friends; neither is declared apart from a friend declaration
// these functions implicitly are members of namespace A
friend void f2();     // won't be found, unless otherwise
friend void f(const C&); // found by argument-dependent
Here, both f and f2 are members of namespace A. Through argument-dependent
lookup, we can call f even if there is no additional declaration for f:
Click here to view code image
int main()
A::C cobj;
f(cobj);   // ok: finds A::f through the friend declaration in A::C
f2();      // error: A::f2 not declared
Because f takes an argument of a class type, and f is implicitly declared in the same
namespace as C, f is found when called. Because f2 has no parameter, it will not be
Exercises Section 18.2.3
Exercise 18.18: Given the following typical definition of swap § 13.3 (p.
517), determine which version of swap is used if mem1 is a string. What if
mem1 is an int? Explain how name lookup works in both cases.
Click here to view code image
C++ Primer, Fifth Edition
void swap(T v1, T v2)
using std::swap;
swap(v1.mem1, v2.mem1);
// swap remaining members of type T
Exercise 18.19: What if the call to swap was std::swap(v1.mem1,
18.2.4. Overloading and Namespaces
Namespaces have two impacts on function matching (§ 6.4, p. 233). One of these
should be obvious: A using declaration or directive can add functions to the
candidate set. The other is much more subtle.
Argument-Dependent Lookup and Overloading
As we saw in the previous section, name lookup for functions that have class-type
arguments includes the namespace in which each argument’s class is defined. This
rule also impacts how we determine the candidate set. Each namespace that defines a
class used as an argument (and those that define its base classes) is searched for
candidate functions. Any functions in those namespaces that have the same name as
the called function are added to the candidate set. These functions are added 
though they otherwise are not visible at the point of the call
Click here to view code image
namespace NS {
class Quote { /* ... */ };
void display(const Quote&) { /* ... */ }
// Bulk_item's base class is declared in namespace NS
class Bulk_item : public NS::Quote { /* ... */ };
int main() {
Bulk_item book1;
return 0;
The argument we passed to display has class type Bulk_item. The candidate
functions for the call to display are not only the functions with declarations that are
in scope where display is called, but also the functions in the namespace where
Bulk_item and its base class, Quote, are declared. The function display(const
Quote&) declared in namespace NS is added to the set of candidate functions.
Documents you may be interested
Documents you may be interested