C++ Primer, Fifth Edition
pos cursor = 0;
pos height = 0, width = 0;
When the compiler processes the multiplication expression inside dummy_fcn, it first
looks for the names used in that expression in the scope of that function. A function’s
parameters are in the function’s scope. Thus, the name height, used in the body of
dummy_fcn, refers to this parameter declaration.
In this case, the height parameter hides the member named height. If we
wanted to override the normal lookup rules, we can do so:
Click here to view code image
// bad practice: names local to member functions shouldn't hide member names
void Screen::dummy_fcn(pos height) {
cursor = width * this->height;   // member height
// alternative way to indicate the member
cursor = width * Screen::height; // member height
Even though the class member is hidden, it is still possible to use that
member by qualifying the member’s name with the name of its class or by
using the this pointer explicitly.
A much better way to ensure that we get the member named height would be to
give the parameter a different name:
Click here to view code image
// good practice: don't use a member name for a parameter or other local variable
void Screen::dummy_fcn(pos ht) {
cursor = width * height;   // member height
In this case, when the compiler looks for the name height, it won’t be found inside
dummy_fcn. The compiler next looks at all the declarations in Screen. Even though
the declaration of height appears after its use inside dummy_fcn, the compiler
resolves this use to the data member named height.
After Class Scope, Look in the Surrounding Scope
If the compiler doesn’t find the name in function or class scope, it looks for the name
in the surrounding scope. In our example, the name height is defined in the outer
Convert pdf to powerpoint presentation - 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
pdf to powerpoint; and paste pdf to powerpoint
Convert pdf to powerpoint presentation - 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 to powerpoint; pdf to powerpoint converter
C++ Primer, Fifth Edition
scope before the definition of Screen. However, the object in the outer scope is
hidden by our member named height. If we want the name from the outer scope,
we can ask for it explicitly using the scope operator:
Click here to view code image
// bad practice: don't hide names that are needed from surrounding scopes
void Screen::dummy_fcn(pos height) {
cursor = width * ::height;// which height? the global one
Even though the outer object is hidden, it is still possible to access that
object by using the scope operator.
Names Are Resolved Where They Appear within a File
When a member is defined outside its class, the third step of name lookup includes
names declared in the scope of the member definition as well as those that appear in
the scope of the class definition. For example:
Click here to view code image
int height;   // defines a name subsequently used inside Screen
class Screen {
typedef std::string::size_type pos;
void setHeight(pos);
pos height = 0;  // hides the declaration of height in the outer scope
Screen::pos verify(Screen::pos);
void Screen::setHeight(pos var) {
// var: refers to the parameter
// height: refers to the class member
// verify: refers to the global function
height = verify(var);
Notice that the declaration of the global function verify is not visible before the
definition of the class Screen. However, the third step of name lookup includes the
scope in which the member definition appears. In this example, the declaration for
verify appears before setHeight is defined and may, therefore, be used.
Exercises Section 7.4.1
Exercise 7.34: What would happen if we put the typedef of pos in the
VB.NET PowerPoint: Use PowerPoint SDK to Create, Load and Save PPT
About This SDK. Specifically speaking, this VB.NET PowerPoint presentation document control of RasterEdge .NET Imaging SDK has been developed and provided to
convert pdf to powerpoint using; pdf picture to powerpoint
VB.NET PowerPoint: Sort and Reorder PowerPoint Slides by Using VB.
you can choose to show your PPT presentation in inverted clip art or screenshot to PowerPoint document slide & profession imaging controls, PDF document, image
table from pdf to powerpoint; convert pdf to ppt
C++ Primer, Fifth Edition
Screen class on page 285 as the last line in the class?
Exercise 7.35: Explain the following code, indicating which definition of
Type or initVal is used for each use of those names. Say how you would
fix any errors.
Click here to view code image
typedef string Type;
Type initVal();
class Exercise {
typedef double Type;
Type setVal(Type);
Type initVal();
int val;
Type Exercise::setVal(Type parm) {
val = parm + initVal();
return val;
7.5. Constructors Revisited
Constructors are a crucial part of any C++ class. We covered the basics of
constructors in § 7.1.4 (p. 262). In this section we’ll cover some additional capabilities
of constructors, and deepen our coverage of the material introduced earlier.
7.5.1. Constructor Initializer List
When we define variables, we typically initialize them immediately rather than defining
them and then assigning to them:
Click here to view code image
string foo = "Hello World!"; // define and initialize
string bar;                  // default initialized to the empty string
bar = "Hello World!";        // assign a new value to bar
Exactly the same distinction between initialization and assignment applies to the data
members of objects. If we do not explicitly initialize a member in the constructor
initializer list, that member is default initialized before the constructor body starts
executing. For example:
Click here to view code image
VB.NET PowerPoint: Merge and Split PowerPoint Document(s) with PPT
individual slide is with the virtual presentation of PPTXPage in VB.NET to finish PowerPoint document splitting If you want to see more PDF processing functions
pdf into powerpoint; pdf to ppt converter online
C# Create PDF from OpenOffice to convert odt, odp files to PDF in
using RasterEdge.XDoc.Excel; using RasterEdge.XDoc.PowerPoint; How to Use C#.NET Demo Code to Convert ODT to PDF in C#.NET Project.
pdf to ppt converter; converting pdf to powerpoint slides
C++ Primer, Fifth Edition
// legal but sloppier way to write the Sales_data constructor: no constructor initializers
Sales_data::Sales_data(const string &s,
unsigned cnt, double price)
bookNo = s;
units_sold = cnt;
revenue = cnt * price;
This version and our original definition on page 264 have the same effect: When the
constructor finishes, the data members will hold the same values. The difference is
that the original version 
its data members, whereas this version 
values to the data members. How significant this distinction is depends on the type of
the data member.
Constructor Initializers Are Sometimes Required
We can often, 
but not always
, ignore the distinction between whether a member is
initialized or assigned. Members that are const or references must be initialized.
Similarly, members that are of a class type that does not define a default constructor
also must be initialized. For example:
class ConstRef {
ConstRef(int ii);
int i;
const int ci;
int &ri;
Like any other const object or reference, the members ci and ri must be initialized.
As a result, omitting a constructor initializer for these members is an error:
Click here to view code image
// error: ci and ri must be initialized
ConstRef::ConstRef(int ii)
             // assignments:
i = ii;   // ok
ci = ii;  // error: cannot assign to a const
ri = i;   // error: ri was never initialized
By the time the body of the constructor begins executing, initialization is complete.
Our only chance to initialize const or reference data members is in the constructor
initializer. The correct way to write this constructor is
Click here to view code image
C# PDF Text Extract Library: extract text content from PDF file in
But sometimes, we need to extract or fetch text content from source PDF document file for word processing, presentation and desktop publishing applications.
and paste pdf into powerpoint; pdf to ppt
VB.NET PowerPoint: VB Codes to Create Linear and 2D Barcodes on
2d barcodes of different types on PowerPoint presentation when you Here is a market-leading PowerPoint barcode add 2d barcodes QR Code, Data Matrix, PDF-417,
converting pdf to ppt online; converting pdf to powerpoint online
C++ Primer, Fifth Edition
// ok: explicitly initialize reference and const members
ConstRef::ConstRef(int ii): i(ii), ci(ii), ri(i) {  }
use the constructor initializer list to provide values for members that
are const, reference, or of a class type that does not have a default
Advice: Use Constructor Initializers
In many classes, the distinction between initialization and assignment is
strictly a matter of low-level efficiency: A data member is initialized and then
assigned when it could have been initialized directly.
More important than the efficiency issue is the fact that some data
members must be initialized. By routinely using constructor initializers, you
can avoid being surprised by compile-time errors when you have a class with
a member that requires a constructor initializer.
Order of Member Initialization
Not surprisingly, each member may be named only once in the constructor initializer.
After all, what might it mean to give a member two initial values?
What may be more surprising is that the constructor initializer list specifies only the
values used to initialize the members, not the order in which those initializations are
Members are initialized in the order in which they appear in the class definition: The
first member is initialized first, then the next, and so on. The order in which initializers
appear in the constructor initializer list does not change the order of initialization.
The order of initialization often doesn’t matter. However, if one member is initialized
in terms of another, then the order in which members are initialized is crucially
As an example, consider the following class:
Click here to view code image
class X {
int i;
int j;
// undefined:  i is initialized before  j
VB.NET Create PDF from OpenOffice to convert odt, odp files to PDF
using RasterEdge.XDoc.Word; using RasterEdge.XDoc.Excel; using RasterEdge.XDoc.PowerPoint; How to VB.NET: Convert ODT to PDF.
change pdf to powerpoint; how to convert pdf to powerpoint in
VB.NET PowerPoint: Add Image to PowerPoint Document Slide/Page
image or clip art to your PowerPoint presentation in VB insert or delete any certain PowerPoint slide without & profession imaging controls, PDF document, tiff
changing pdf to powerpoint file; convert pdf slides to powerpoint
C++ Primer, Fifth Edition
X(int val): j(val), i(j) { }
In this case, the constructor initializer makes it 
as if j is initialized with val
and then j is used to initialize i. However, i is initialized first. The effect of this
initializer is to initialize i with the undefined value of j!
Some compilers are kind enough to generate a warning if the data members are
listed in the constructor initializer in a different order from the order in which the
members are declared.
Best Practices
It is a good idea to write constructor initializers in the same order as the
members are declared. Moreover, when possible, avoid using members to
initialize other members.
If possible, it is a good idea write member initializers to use the constructor’s
parameters rather than another data member from the same object. That way we
don’t even have to think about the order of member initialization. For example, it
would be better to write the constructor for X as
Click here to view code image
X(int val): i(val), j(val) { }
In this version, the order in which i and j are initialized doesn’t matter.
Default Arguments and Constructors
The actions of the Sales_data default constructor are similar to those of the
constructor that takes a single string argument. The only difference is that the
constructor that takes a string argument uses that argument to initialize bookNo.
The default constructor (implicitly) uses the string default constructor to initialize
bookNo. We can rewrite these constructors as a single constructor with a default
argument (§ 6.5.1, p. 236):
Click here to view code image
class Sales_data {
// defines the default constructor as well as one that takes a string argument
Sales_data(std::string s = ""): bookNo(s) { }
// remaining constructors unchanged
Sales_data(std::string s, unsigned cnt, double rev):
bookNo(s), units_sold(cnt), revenue(rev*cnt) { }
Sales_data(std::istream &is) { read(is, *this); }
// remaining members as before
C++ Primer, Fifth Edition
This version of our class provides the same interface as our original on page 264.
Both versions create the same object when given no arguments or when given a
single string argument. Because we can call this constructor with no arguments, this
constructor defines a default constructor for our class.
A constructor that supplies default arguments for all its parameters also
defines the default constructor.
It is worth noting that we probably should not use default arguments with the
Sales_data constructor that takes three arguments. If a user supplies a nonzero
count for the number of books sold, we want to ensure that the user also supplies the
price at which those books were sold.
Exercises Section 7.5.1
Exercise 7.36: The following initializer is in error. Identify and fix the
Click here to view code image
struct X {
X (int i, int j): base(i), rem(base % j) { }
int rem, base;
Exercise 7.37: Using the version of Sales_data from this section,
determine which constructor is used to initialize each of the following
variables and list the values of the data members in each object:
Click here to view code image
Sales_data first_item(cin);
int main() {
Sales_data next;
Sales_data last("9-999-99999-9");
Exercise 7.38: We might want to supply cin as a default argument to the
constructor that takes an istream&. Write the constructor declaration that
uses cin as a default argument.
Exercise 7.39: Would it be legal for both the constructor that takes a
string and the one that takes an istream& to have default arguments? If
not, why not?
Exercise 7.40: Choose one of the following abstractions (or an abstraction
C++ Primer, Fifth Edition
of your own choosing). Determine what data are needed in the class. Provide
an appropriate set of constructors. Explain your decisions.
(a) Book
(b) Date
(c) Employee
(d) Vehicle
(e) Object
(f) Tree
7.5.2. Delegating Constructors
The new standard extends the use of constructor initializers to let us define so-called
delegating constructors. A delegating constructor uses another constructor from its
own class to perform its initialization. It is said to “delegate” some (or all) of its work
to this other constructor.
Like any other constructor, a delegating constructor has a member initializer list and
a function body. In a delegating constructor, the member initializer list has a single
entry that is the name of the class itself. Like other member initializers, the name of
the class is followed by a parenthesized list of arguments. The argument list must
match another constructor in the class.
As an example, we’ll rewrite the Sales_data class to use delegating constructors as
Click here to view code image
class Sales_data {
// nondelegating constructor initializes members from corresponding arguments
Sales_data(std::string s, unsigned cnt, double price):
bookNo(s), units_sold(cnt), revenue(cnt*price) {
// remaining constructors all delegate to another constructor
Sales_data(): Sales_data("", 0, 0) {}
Sales_data(std::string s): Sales_data(s, 0,0) {}
Sales_data(std::istream &is): Sales_data()
{ read(is, *this); }
// other members as before
In this version of Sales_data, all but one of the constructors delegate their work.
The first constructor takes three arguments, uses those arguments to initialize the
data members, and does no further work. In this version of the class, we define the
C++ Primer, Fifth Edition
default constructor to use the three-argument constructor to do its initialization. It too
has no additional work, as indicated by the empty constructor body. The constructor
that takes a string also delegates to the three-argument version.
The constructor that takes an istream& also delegates. It delegates to the default
constructor, which in turn delegates to the three-argument constructor. Once those
constructors complete their work, the body of the istream& constructor is run. Its
constructor body calls read to read the given istream.
When a constructor delegates to another constructor, the constructor initializer list
and function body of the delegated-to constructor are both executed. In
Sales_data, the function bodies of the delegated-to constructors happen to be
empty. Had the function bodies contained code, that code would be run before control
returned to the function body of the delegating constructor.
Exercises Section 7.5.2
Exercise 7.41: Rewrite your own version of the Sales_data class to use
delegating constructors. Add a statement to the body of each of the
constructors that prints a message whenever it is executed. Write
declarations to construct a Sales_data object in every way possible. Study
the output until you are certain you understand the order of execution among
delegating constructors.
Exercise 7.42: For the class you wrote for exercise 7.40 in § 7.5.1 (p. 291),
decide whether any of the constructors might use delegation. If so, write the
delegating constructor(s) for your class. If not, look at the list of abstractions
and choose one that you think would use a delegating constructor. Write the
class definition for that abstraction.
7.5.3. The Role of the Default Constructor
The default constructor is used automatically whenever an object is default or value
initialized. Default initialization happens
• When we define nonstatic variables (§ 2.2.1, p. 43) or arrays (§3.5.1, p.
114) at block scope without initializers
• When a class that itself has members of class type uses the synthesized default
constructor (§ 7.1.4, p. 262)
• When members of class type are not explicitly initialized in a constructor
initializer list (§ 7.1.4, p. 265)
Value initialization happens
• During array initialization when we provide fewer initializers than the size of the
C++ Primer, Fifth Edition
array (§ 3.5.1, p. 114)
• When we define a local static object without an initializer (§ 6.1.1, p. 205)
• When we explicitly request value initialization by writing an expressions of the
form T() where T is the name of a type (The vector constructor that takes a
single argument to specify the vector’s size (§ 3.3.1, p. 98) uses an argument
of this kind to value initialize its element initializer.)
Classes must have a default constructor in order to be used in these contexts. Most of
these contexts should be fairly obvious.
What may be less obvious is the impact on classes that have data members that do
not have a default constructor:
Click here to view code image
class NoDefault {
NoDefault(const std::string&);
// additional members follow, but no other constructors
struct A {  // my_mem is public by default; see § 7.2 (p. 268)
NoDefault my_mem;
A a;       //  error: cannot synthesize a constructor for A
struct B {
B() {} //  error: no initializer for b_member
NoDefault b_member;
Best Practices
In practice, it is almost always right to provide a default constructor if other
constructors are being defined.
Using the Default Constructor
The following declaration of obj compiles without complaint. However, when we try
to use obj
Click here to view code image
Sales_data obj();   // ok: but defines a function, not an object
if (obj.isbn() == Primer_5th_ed.isbn())  // error: obj is a function
the compiler complains that we cannot apply member access notation to a function.
The problem is that, although we intended to declare a default-initialized object, obj
actually declares a function taking no parameters and returning an object of type
Documents you may be interested
Documents you may be interested