1. C++ Programming Languages
Sharif University of Technology
C++ Programming Languages
Lecturer: Omid Jafarinezhad
Fall 2013
Lecture 3
Department of Computer Engineering

2. Outline Differences between C and C++ Extensions to C Namespaces
String
IOStreams (input, output, file)

3. Differences between C and C++
Strict type checking
// Ok in C , Error in C ++
int main() {
// Error : printf undeclared
printf("Hello World\n"); }
// Ok in C++
#include <stdio.h>
int main() {
printf("Hello World\n"); }
int main() {
// Error in C++: return-statement with no value, in function returning 'int'
return; }
// Ok in C++
int main() { }

4. Extensions to C Function Overloading #include <stdio.h>
void show(int val) { printf("Integer: %d\n", val); }
void show(double val) { printf("Double: %lf\n", val); }
void show(char const *val) { printf("String: %s\n", val); }
int main() {
show(12);
show(3.1415);
show("Hello World!\n"); }

5. Extensions to C Function Overloading:
Do not use function overloading for functions doing conceptually different tasks.
C++ does not allow identically named functions to differ only in their return values.

6. Extensions to C Default function arguments #include <stdio.h>
int Sum(int a = 1, int b = 4) {return a + b;}
int main() {
printf("%d", Sum()); // arguments:
printf("%d”, Sum(20)); // arguments:
printf("%d", Sum(20, 5)); // arguments:
// Sum(,6); // Error }

7. Extensions to C Default function arguments
Default arguments must be known at compile-time since at that moment arguments are supplied to functions. Therefore, the default arguments must be mentioned at the function's declaration, rather than at its implementation:
// sample header file
extern void two_ints(int a = 1, int b = 4);
// code of function in, filename.ccp
void two_ints(int a, int b) { ... }

8. Differences between C and C++
NULL-pointers , 0-pointers and nullptr (C++ 11)
#include <stdio.h>
void show(int val) { printf("Integer: %d\n", val); }
void show(double val) { printf("Double: %lf\n", val); }
void show(char const *val) { printf("String: %s\n", val); }
int main() {
show(0);
show(NULL); // show(0);
show((char *)0);
show(nullptr); // in C++ 11 }

9. Differences between C and C++
The void parameter list
#include <stdio.h>
void show();
int main() {
show(10); }
void show(int val) { printf("Integer: %d\n", val); }
C ()
C++ ()

10. Differences between C and C++
The void parameter list
#include <stdio.h>
void show(void);
int main() {
show(10); // Error too many arguments to function }
void show(int val) { printf("Integer: %d\n", val); }
C ()
C++ ()

11. Differences between C and C++
Defining local variables
#include <stdio.h>
int main() {
for (int i = 0; i < 20; ++i)
printf("%d\n", i);
switch (int c = getchar())
.... }
if (int c = getchar()) ….

12. Differences between C and C++
typedef
The keyword typedef is still used in C++, but is not required anymore when defining union, struct or enum definitions.
struct SomeStruct {
int a;
double d;
char string[80]; };
SomeStruct what; // in c : struct SomeStruct what;
what.d = ;

13. Extensions to C The scope resolution operator ::
#include <stdio.h>
int counter = 50; // global variable
int main() {
int counter = 10;
for (int counter = 1; // this refers to the
counter < 10; // local variable
counter++)
printf("%d\n",
::counter // global variable
/ // divided by
counter); // local variable }

14. Extensions to C cout, cin, and cerr cout, analogous to stdout
cin, analogous to stdin
cerr, analogous to stderr

15. Extensions to C #include <iostream> using namespace std;
int main() {
int ival;
char sval[30];
std::cout << "Enter a number:\n"; // <<, insertion operator
cin >> ival; // >>, extraction operator
cout << "And now a string:\n";
cin >> sval;
cout << "The number is: " << ival << "\n"
"And the string is: " << sval << '\n'; }

16. Extensions to C Functions as part of a struct /* in C ++ */
struct Person {
char name[80];
char address[80];
void print(); };
void Person::print()
cout << "Name:" << name << "\n"
"Address: " << address << "\n"; }
Person person;
strcpy(person.name, "Karel");
person.print();
/* in C and C++*/
typedef struct {
char name[80];
char address[80];
} PERSON;
/* print information */
void print(PERSON const *p){…}
/* etc.. */

17. Extensions to C References
the reference operator & indicates that ref is not itself an int but a reference to one
synonyms for variables
A reference to a variable is like an alias
// c++
int int_value;
int &ref = int_value;
++int_value;
++ref;
// c and c++
int int_value;
int *ref = &int_value;
++int_value;
++(*ref);

18. Extensions to C References // c++ void increase(int &valr) {}
int main()
int x;
increase(x);
// c and c++
void increase(int *valp) {
*valp += 5; }
int main()
int x;
increase(&x);

19. Extensions to C References extern int *ip; extern int &ir;
ip = 0; // reassigns ip, now a 0-pointer
ir = 0; // ir unchanged, the int variable it refers to is now 0
int &q; // Error : declared as reference but not initialized

20. Extensions to C References could result in extremely ugly code
int &func() {
static int value;
return value; }
int main()
func() = 20;
func() += func();

21. Extensions to C Rvalue References (C++11)
lvalue reference (typename &)
rvalue references (typename &&)
int intVal() {
return 5; }
int &ir = intVal(); // fails: refers to a temporary
int const &ic = intVal(); // OK: immutable temporary
int *ip = &intVal(); // fails: no lvalue available

22. Extensions to C Rvalue References (C++11)
void receive(int &value) // note: lvalue reference {
cout << "int value parameter\n"; }
void receive(int &&value) // note: rvalue reference
cout << "int R-value parameter\n";
int main()
receive(18); // int R-value parameter
int value = 5;
receive(value); // int value parameter
receive(intVal()); // int R-value parameter

23. Memory leak
#include <stdlib.h> void function_which_allocates(void) { /* allocate an array of 45 floats */ float * a = malloc(sizeof(float) * 45); /* additional code making use of 'a' */ /* return to main, having forgotten to free the memory we malloc'd */ } int main(void) function_which_allocates(); /* the pointer 'a' no longer exists, and therefore cannot be freed, but the memory is still allocated. a leak has occurred. */

24. Extensions to C Memory leak struct Data int main() { { char *text;
size_t size;
void copy(Data const &other)
text = strdup(other.text);
size = strlen(text); } };
Data dataFactory(char const *txt)
Data ret = {strdup(txt), strlen(txt)};
return ret;
int main() {
Data d1 = {strdup("hello"), strlen("hello")};
Data d2;
d2.copy(d1);
Data d3;
d3.copy(dataFactory("hello")); }

25. Extensions to C Rvalue References (C++11) other.text = 0; struct Data{
// ….
void copy(Data &&other)
text = other.text;
other.text = 0; } };
Data dataFactory(char const *txt)
Data ret = {strdup(txt), strlen(txt)};
return ret;
int main() {
Data d1 = {strdup("hello"), strlen("hello")};
Data d2;
d2.copy(d1);
Data d3;
d3.copy(dataFactory("hello")); }

26. Extensions to C Strongly typed enumerations (C++11)
enum class SafeEnum {
NOT_OK, // 0, by implication
OK = 10,
MAYBE_OK // 11, by implication };
enum class CharEnum: unsigned char
NOT_OK, OK
// CharEnum::OK

27. Extensions to C enumerations in c and c++ #include <iostream>
using namespace std;
enum Color {
        RED, // 0
        BLUE // 1 };
enum Fruit
        BANANA, // 0
        APPLE // 1
int main() {
    Color a = RED;
    Fruit b = BANANA;
  // The compiler will compare a and b as integers
    if (a == b)
        // and find they are equal!
cout << "a and b are equal" << endl;
    else
        cout << "a and b are not equal" << endl;
    return 0; }

28. Extensions to C Strongly typed enumerations (C++11)
#include <iostream>
using namespace std;
enum class Color {
        RED, // 0
        BLUE // 1 };
enum class Fruit
        BANANA, // 0
        APPLE // 1
int main() {
    Color a = Color::RED;
    Fruit b = Fruit::BANANA;
/* compile error here, as the compiler doesn't know how to compare different types Color and Fruit */
    if (a == b)
cout << "a and b are equal" << endl;
    else
        cout << "a and b are not equal" << endl;
    return 0; }

29. Extensions to C Type inference: auto and decltype (C++11)
auto variable = 5; // int x = 4;
auto d = 2.5; // d will be type double
auto z = d; // z will be type double
auto w = "hi"; // w will be type const char*
decltype(5) x; // x will be type int because 5 is an int
decltype(x) y = 6; // y will be type int because x is an int
auto z = x; // z will type type int
int multiply (int x, int y){…}
auto multiply (int x, int y) -> int{…}

30. Extensions to C function declaration using auto (C++11)
#include <iostream>
#include <string>
// simple function with a default argument, returning nothing
void f0(const std::string& arg = "world") {
std::cout << "Hello, " << arg << '\n'; }
// function returning a pointer to f0, (C++11 style)
auto fp11() -> void(*)(const std::string&) {
return f0;
// c and c++ (pre-C++11 style)
// function returning a pointer to f0
void (*fp03())(const std::string&) {
int main() {
f0();
fp11()("test");
fp03()("again"); }
// output
Hello, world
Hello, test
Hello, again

31. Extensions to C Range-based for-loops (C++11) struct BigStruct {
double array[100];
int last; };
BigStruct data[100]; // assume properly initialized elsewhere
int countUsed()
int sum = 0;
// const &: the elements aren't modified
for (auto const &element: data)
sum += element.last;
return sum; }
// assume int array[30]
for (auto &element: array)
statement

32. Extensions to C binary constant data types e.g. int i = 0b101;
void, char, short, int, long, float and double
bool, wchar_t, long long and long double
char16_t and char32_t
size_t (typedef long unsigned int size_t)

33. Extensions to C Bool bool bValue; // true (!=0) or false (0)
bool bValue1 = true; // explicit assignment
bool bValue2(false); // implicit assignment
bool bValue1 = !true; // bValue1 will have the value false
bool bValue2(!false); // bValue2 will have the value true
bool bValue = true; // bool bValue = 30;
cout << bValue << endl; // 1
cout << !bValue << std::endl; // 0
if (!bValue)
    cout << "The if statement was true" << endl;
else
    cout << "The if statement was false" << endl;

34. Extensions to C The static_cast conversion The dynamic_cast conversion
static_cast<type>(expression);
int x = 19;
int y = 4;
sqrt(x / y);
sqrt(static_cast<double>(x) / y);
The dynamic_cast conversion
The const_cast conversion
The reinterpret_cast conversion

35. Namespaces Defining namespaces // in file1.cpp namespace CppNS {
double cos(double argInDegrees)
... }
// in file2.cpp
double sin(double argInDegrees)
// same as file3.ccp
namespace CppNS {
double cos(double argInDegrees)
... }
double sin(double argInDegrees)

36. Namespaces Referring to namespaces #include <file3>
#include <iostream>
#include <cmath>
using namespace std;
int main() {
cout << "The cosine of 60 degrees is: "
<< CppNS::cos(60)
<< ::cos(60); // call the standard std::cos(60) function }
// same as file3.ccp
namespace CppNS {
double cos(double argInDegrees)
{ … }
double sin(double argInDegrees) }

37. Namespaces Referring to namespaces #include <file3>
#include <iostream>
#include <cmath>
using namespace std;
int main() {
using CppNS::cos;
/* ... */
cout << cos(60) // calls CppNS::cos()
<< ::cos(60); // call the standard std::cos(60) function }
// same as file3.ccp
namespace CppNS {
double cos(double argInDegrees)
{ … }
double sin(double argInDegrees) }

38. Namespaces The standard namespace The std namespace is reserved by C++
The standard defines many entities that are part of the runtime available software
e.g., cout, cin, cerr
the templates defined in the Standard Template Library
the Generic Algorithms

39. Namespaces Nesting namespaces #include <file3> int main() {
CppNS::value = 0;
CppNS::Virtual::pointer = 0; }
// same as file3.ccp
namespace CppNS {
int value;
namespace Virtual
void *pointer; }
#include <file3>
using namespace CppNS;
int main() {
value = 0;
Virtual::pointer = 0; }

40. Namespaces Nesting namespaces #include <file3>
using namespace CppNS;
using namespace Virtual;
int main() {
value = 0;
pointer = 0; }
// same as file3.ccp
namespace CppNS {
int value;
namespace Virtual
void *pointer; }
#include <file3>
using namespace CppNS ::Virtual;
int main() {
CppNS ::value = 0;
pointer = 0; }

41. Namespaces Namespace aliasing #include <file3>
namespace CV = CppNS::Virtual;
int main() {
CV::pointer = 0; }
// same as file3.ccp
namespace CppNS {
int value;
namespace Virtual
void *pointer; }
#include <file3>
namespace CV = CppNS::Virtual; using namespace CV;
int main() {
pointer = 0; }

42. Namespaces Defining entities outside of their namespaces
#include <file3>
namespace CppNS {
namespace Virtual
void *pointer;
typedef int INT8[8];
INT8 *squares(); }
// out side the namespace such as in cpp file
CppNS::Virtual::INT8 * CppNS ::Virtual::squares()
/* … */
namespace CppNS {
namespace Virtual
void *pointer;
typedef int INT8[8];
INT8 *squares()
/* … */ }

43. String std::string public class string { /* … */
string& string::operator= (const string& str); string& string::assign (const string& str); string& string::operator= (const char* str); string& string::assign (const char* str); string& string::operator= (char c); }
#include <iostream>
#include <string>
using namespace std;
int main() {
string sString;
sString = string("One");
cout << sString << endl;  // One
const string sTwo("Two");
sString.assign(sTwo);
cout << sString << endl;  // Two
sString = "Three"; // Assign a C-style string
cout << sString << endl;  // Three
sString.assign("Four");
cout << sString << endl;  // Four
sString = '5'; // Assign a char
cout << sString << endl;  // 5
string sOther; // Chain assignment
sString = sOther = "Six";
cout << sString << " " << sOther << endl; // Six Six }

44. String std::string assignment and swapping
const string sSource("abcdefg");
string sDest;
sDest.assign(sSource, 2, 4);
cout << sDest << endl; // cdef
sDest.assign("abcdefg", 4);
cout << sDest << endl; // abcd
sDest.assign(4, 'g');
cout << sDest << endl; // gggg
string sStr1("red");
string sStr2("blue);
cout << sStr1 << " " << sStr2 << endl; // red blue
swap(sStr1, sStr2);
cout << sStr1 << " " << sStr2 << endl; // blue red
sStr1.swap(sStr2);
cout << sStr1 << " " << sStr2 << endl; // red blue

45. String std::string inserting #include <iostream>
#include <string>
using namespace std;
int main() {
string sString("aaaa");
cout << sString << endl; // aaaa
sString.insert(2, string("bbbb"));
cout << sString << endl; // aabbbbaa
sString.insert(4, "cccc");
cout << sString << endl; // aabbccccbbaa
const string sInsert(" ");
// insert substring of sInsert from index [3,7) into sString at index 2
sString.insert(2, sInsert, 3, 4); // aa3456bbccccbbaa
cout << sString << endl; }

46. String std::string appending string sString("one");
sString += string(" two"); // sString += " two";
string sThree(" three");
sString.append(sThree);
cout << sString << endl; // one two three
string sString("one ");
const string sTemp("twothreefour");
// append substring of sTemp starting at index 3 of length 5
sString.append(sTemp, 3, 5);
cout << sString << endl; // one three

47. String std::string Member functions
at access specified character with bounds checking clear clears the contents
insert inserts characters erase removes characters
compare compares two strings replace replaces specified portion of a string substr returns a substring copy copies characters
find find characters in the string rfind find the last occurrence of a substring find_first_of find first occurrence of characters find_last_of find last occurrence of characters /* … */

48. String std::string Member functions
#include <stdexcept>
#include <iostream>
int main() {
std::string s("message"); // for capacity
s = "abc";
s.at(2) = 'x'; // ok
std::cout << s << '\n';
std::cout << "string size = " << s.size() << '\n';
std::cout << "string capacity = " << s.capacity() << '\n';
try { // throw, even if capacity allowed to access element
s.at(3) = 'x'; }
catch (std::out_of_range& exc) { std::cout << exc.what() << '\n‘; }
abx
string size = 3
string capacity = 7
basic_string::at

49. String std::string Convert from strings
C++11 added several string conversion functions
stoi Convert string to integer
stol Convert string to long int
stoul Convert string to unsigned integer
stoll Convert string to long long
stoull Convert string to unsigned long long
stof Convert string to float
stod Convert string to double
stold Convert string to long double
int stoi (const string& str, size_t* idx = 0, int base = 10);
std::string str_bin = " ";
int i_bin = std::stoi (str_bin,nullptr,2);
std::cout << str_bin << ": " << i_bin; // : -1201

50. IOStreams Input/output in C++
istream class, extraction operator (>>)
ostream class, insertion operator (<<)
#include <iostream>
using namespace std;
int main() {
cout << "Enter your age: " << endl; // print text to the monitor
int nAge;
cin >> nAge; // get input from the user
if (nAge <= 0) { // print an error message
cerr << "Oops, you entered an invalid age!" << endl;
return 1; }
cout << "You entered " << nAge << " years old" << endl;
return 0;

51. IOStreams extraction operator (>>) char buf[10];
cin >> buf; // what happens if the user enters 18 characters? /*
* C++ provides a manipulator known as setw (in the iomanip.h header) that can * be used to limit the number of characters read in from a stream. */
#include <iomanip.h>
cin >> setw(10) >> buf;
/* Any remaining characters will be left in the stream until the next extraction */

52. IOStreams extraction operator (>>) /*
The one thing that we have omitted to mention so far is that the extraction operator works with “formatted” data — that is, it skips whitespace (blanks, tabs, and newlines) */
char ch;
while (cin >> ch) input : Hello my name is Omid
        cout << ch; output: HellomynameisOmid
while (cin.get(ch)) input : Hello my name is Omid
        cout << ch; output : Hello my name is Omid

53. IOStreams extraction operator (>>) char strBuf[11];
// only read the first 10 characters
cin.get(strBuf, 11); input : Hello my name is Omid
cout << strBuf << endl; output : Hello my n
/* One important thing to note about get() is that it does not read in a newline character! This can cause some unexpected results */
cin.get(strBuf, 11); input : Hello! 
cout << strBuf << endl; output : Hello
cin.get(strBuf, 11);
cout << strBuf << endl;
/* Consequently, getline() like get() but reads the newline as well */

54. IOStreams extraction operator (>>)
/* If you need to know how many character were extracted by the last call of getline(), use gcount() */
char strBuf[100];
cin.getline(strBuf, 100);
cout << strBuf << endl;
cout << cin.gcount() << " characters were read" << endl;
// A special version of getline() for std::string
string strBuf;
getline(cin, strBuf);

55. IOStreams insertion operator (<<)
/* To switch a flag on, use the setf() function To turn a flag off, use the unsetf() function */
cout.setf(ios::showpos); // turn on the ios::showpos flag
cout << 27 << endl; // output : +27
cout.unsetf(ios::showpos); // turn off the ios::showpos flag
cout << 28 << endl; // output : 28
cout.setf(ios::showpos | ios::uppercase);
// basefield : “oct”, “dec”, and “hex”
cout.unsetf(ios::dec); // turn off decimal output
cout.setf(ios::hex); // turn on hexadecimal output
cout << 27 << endl; // output : 1b
cout << hex << 27 << endl; // print 27 in hex : 1b
cout << 28 << endl; // we're still in hex : 1c
cout << dec << 29 << endl; // back to decimal: 29

56. IOStreams insertion operator (<<)
cout << true << " " << false << endl; // 0 1
 cout.setf(ios::boolalpha);
cout << true << " " << false << endl; // true false
cout << noboolalpha << true << " " << false << endl; // 0 1
 cout << boolalpha << true << " " << false << endl; // true false
cout << fixed << endl; // Use decimal notation for values
cout << setprecision(3) << << endl; //
cout << setprecision(4) << << endl; //

57. IOStreams insertion operator (<<)
showpos Prefixes positive numbers with a +
noshowpos Doesn’t prefix positive numbers with a +
fixed Use decimal notation for values
scientific Use scientific notation for values
showpoint Show a decimal point and trailing 0′s for floating-point values
noshowpoint Don’t show a decimal point and trailing 0′s for floating-point values
setprecision(int) Sets the precision of floating-point numbers (iomanip.h)
precision() Returns the current precision of floating-point numbers
precision(int) Sets the precision of floating-point numbers and returns old precision
internal Left-justifies the sign of the number, and right-justifies the value
left Left-justifies the sign and value
right Right-justifies the sign and value
setfill(char) Sets the parameter as the fill character (iomanip.h)
setw(int) Sets the field width for input and output to the parameter (iomanip.h)
fill() Returns the current fill character
fill(char) Sets the fill character and returns the old fill character
width() Returns the current field width
width(int) Sets the current field width and returns old field width

58. IOStreams insertion operator (<<)
cout << << endl; // print default value with no field width
cout << setw(10) << << endl; // print default with field width
cout << setw(10) << left << << endl; // print left justified
cout << setw(10) << right << << endl; // print right justified
cout << setw(10) << internal << << endl; // print internally justified
cout.fill('*');
cout << << endl;
cout << setw(10) << << endl;
cout << setw(10) << left << << endl;
cout << setw(10) << right << << endl;
cout << setw(10) << internal << << endl;
-12345
****-12345
-12345****
-****12345

59. IOStreams Stream classes for strings
One of the primary uses of string streams is to buffer output for display at a later time, or to process input line-by-line
#include <sstream>
stringstream os;
os << "en garde!" << endl; // set the stringstream buffer to "en garde!“
os.str("en garde!"); // set the stringstream buffer to "en garde!“
cout << os.str();
os.str(""); os.str(std::string()); os.clear(); // erase the buffer
os << " "; // insert a string of numbers into the stream
string strValue;
os >> strValue;
string strValue2;
os >> strValue2;
cout << strValue << " - " << strValue2 << endl; //
int nValue;
double dValue;
 os >> nValue >> dValue;

60. IOStreams Stream states (Flags)
Operations on streams may fail for various reasons. Whenever an operation fails, further operations on the stream are suspended. It is possible to inspect, set and possibly clear the condition state of streams, allowing a program to repair the problem rather than having to abort.
ios::goodbit
Everything is okay (none of the other three condition flags)
ios::badbit
Some kind of fatal error occurred (eg. the program tried read past the end of a file)
ios::eofbit
The stream has reached the end of a file
ios::failbit
A non-fatal error occurred (eg. the user entered letters when the program was expecting an integer)

61. Stream states - Member function
IOStreams
Stream states - Member function
good() Returns true if the goodbit is set
bad() Returns true if the badbit is set
eof() Returns true if the eofbit is set
fail() Returns true if the failbit is set
clear() Clears all flags and restores the stream to the goodbit
clear(state) Clears all flags and sets the state flag passed in
rdstate() Returns the currently set flags
setstate(state) Sets the state flag passed in

62. Stream states - Member function
IOStreams
Stream states - Member function
void state() {
cout << cin.bad() << cin.fail() << cin.eof() << cin.good() << '\n'; }
int main() {
string line;
int x;
cin >> x; // omid 
state(); // 0100
cin.clear();
cin >> line; // omid
state(); // 0001
getline(cin, line); // 
/* Whenever an operation fails, further operations on the stream are suspended */
// cin.clear();
cin >> line; // suspended
state(); // 0100
getline(cin, line); // suspended

63. Stream states IOStreams if (cin) // if (not cin.fail())
if (cin >> x) // if (not (cin >> x).fail())
if (getline(cin, str)) // if (not getline(cin, str).fail())

64. Input validation IOStreams Function Return value
isalnum(int) non-zero if the input is a letter or a digit
isalpha(int) non-zero if the input is a letter
iscntrl(int) non-zero if the input is a control character
isdigit(int) non-zero if the input is a digit
isgraph(int) non-zero if the input is printable character that is not whitespace
isprint(int) non-zero if the input is printable character (including whitespace)
ispunct(int) non-zero if the input is neither alphanumeric nor whitespace
isspace(int) non-zero if the input is whitespace
isxdigit(int) non-zero if the input is a hexadecimal digit (0-9, a-f, A-F)

65. Input validation IOStreams cout << "Enter your age: ";
string strAge;
cin >> strAge;
// Check to make sure each character is a digit
for (unsigned int nIndex=0; nIndex < strAge.length(); nIndex++)
if (!isdigit(strAge[nIndex])) { …. }

66. Your practice: run it
int nAge; string str; while (1) { cout << "Enter your age: "; cin >> nAge; // user enter the following : 23dncdlklkd if (cin.fail()) // no extraction took place cin.clear(); // reset the state bits back to goodbit so we can use ignore() cin.ignore(1000, '\n'); // clear out the bad input from the stream continue; // try again } cin.ignore(1000, '\n'); // clear out any additional input from the stream if (nAge <= 0) // make sure nAge is positive continue; cin >> str; break;

67. IOStreams File ifstream (derived from istream)
file input
ofstream (derived from ostream)
output file
fstream (derived from iostream).
input/output file
fstream.h

68. File output IOStreams #include <fstream>
#include <iostream>
// ofstream is used for writing files.
// We'll make a file called Sample.dat
    ofstream outf("Sample.dat");
    // If we couldn't open the output file stream for writing
    if (!outf) // Print an error and exit
    {   …  }
     // We'll write two lines into this file
    outf << "This is line 1" << endl;
    outf << "This is line 2" << endl;

69. IOStreams
Output File
ifstream returns a 0 if we’ve reached the end of the file (EOF)
#include <fstream>
#include <iostream>
// ifstream is used for reading files
    // We'll read from a file called Sample.dat
     ifstream inf("Sample.dat");  
    // If we couldn't open the output file stream for writing
    if (!inf) // Print an error and exit
    {   …  }
    // While there's still stuff left to read
    while (inf)
    {
        // read stuff from the file into a string and print it
        std::string strInput;
        inf >> strInput; getline(inf, strInput);
        cout << strInput << endl;
    }

70. Reference http://en.cppreference.com/w/