rsity of Technology
C++ Programming Languages
turer:
Omid Jafarinezhad
Fall 2015
Lecture 3
Department of Computer Engineering
tline
• Differences between C and C++
• Extensions to C
• Namespaces
• String
• IOStreams (input, output, file)
tween 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() { }
ons 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");
}
ons to C
• Function Overloading:
–Do not use function overloading for functions doing conce
–C++ does not allow identically named functions to differ o
ons to C
• Default function arguments
#include <stdio.h>
int Sum(int a = 1, int b = 4) {return a + b;}
int main()
{
printf("%d", Sum());
printf("%d”, Sum(20));
printf("%d", Sum(20, 5));
// Sum(,6);
}
// arguments: 1 + 4
// arguments: 20 + 4
// arguments: 20 + 5
// Error
ons to C
• Default function arguments
–Default arguments must be known at compile-time since a
// 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) { ... }
tween 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
}
tween C and C++
• The void parameter list
#include <stdio.h>
void show();
int main()
{
show(10);
}
C ()
C++ ()
void show(int val) { printf("Integer: %d\n", val); }
tween C and C++
• The void parameter list
#include <stdio.h>
void show(void);
C ()
C++ ()
int main()
{
show(10); // Error too many arguments to function
}
void show(int val) { printf("Integer: %d\n", val); }
tween 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()) ….
}
tween C and C++
• typedef
–The keyword typedef is still used in C++, but is not require
struct SomeStruct
{
int a;
double d;
char string[80];
};
SomeStruct what; // in c : struct SomeStruct what;
what.d = 3.1415;
ons to C
• The scope resolution operator ::
#include <stdio.h>
int counter = 50;
int main()
{
int counter = 10;
for (int counter = 1;
counter < 10;
counter++)
{
printf("%d\n",
::counter
/
counter);
}
}
// global variable
// this refers to the
// local variable
// global variable
// divided by
// local variable
ons to C
• cout, cin, and cerr
–cout, analogous to stdout
–cin, analogous to stdin
–cerr, analogous to stderr
ons to C
#include <iostream>
using namespace std;
int main()
{
int ival;
char sval[30];
std::cout << "Enter a number:\n";
cin >> ival;
cout << "And now a string:\n";
cin >> sval;
// <<, insertion operator
// >>, extraction operator
cout << "The number is: " << ival << "\n"
"And the string is: " << sval << '\n';
}
ons 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.. */
ons to C
• References
–the reference operator & indicates that ref is not itself an
–synonyms for variables
–A reference to a variable is like an alias
// c++
int int_value;
int &ref = int_value;
// c and c++
int int_value;
int *ref = &int_value;
++int_value;
++ref;
++int_value;
++(*ref);
ons to C
• References
// c++
void increase(int &valr)
{
valr += 5;
}
// c and c++
void increase(int *valp)
{
*valp += 5;
}
int main()
{
int x;
increase(x);
}
int main()
{
int x;
increase(&x);
}
ons 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
ons to C
• References could result in extremely ugly code
int &func()
{
static int value;
return value;
}
int main()
{
func() = 20;
func() += func();
}
ons 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
ons 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
}
ry 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 me
}
int main(void)
{
function_which_allocates();
ons to C
• Memory leak
struct Data
{
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"));
}
ons to C
• Rvalue References (C++11)
struct Data
{
// ….
void copy(Data &&other)
{
text = other.text;
int main()
{
Data d1 = {strdup("hello"),
strlen("hello")};
Data d2;
d2.copy(d1);
other.text = 0;
}
};
Data dataFactory(char const *txt)
{
Data ret = {strdup(txt), strlen(txt)};
return ret;
}
Data d3;
d3.copy(dataFactory("hello"));
}
ons 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
ons 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;
}
ons 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 h
if (a == b)
cout << "a and b are equal" << endl;
else
cout << "a and b are not equal" << endl;
return 0;
}
ons to C
• Type inference: auto and decltype (C++11)
auto variable = 5;
auto d = 2.5;
auto z = d;
auto w = "hi";
// int x = 4;
// d will be type double
// z will be type double
// 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{…}
ons 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") {
int main()
std::cout << "Hello, " << arg << '\n';
{
}
f0();
// function returning a pointer to f0, (C++11 style)
fp11()("test");
auto fp11() -> void(*)(const std::string&) {
fp03()("again");
return f0;
}
}
// output
// c and c++ (pre-C++11 style)
Hello, world
// function returning a pointer to f0
Hello, test
void (*fp03())(const std::string&) {
Hello, again
return f0;
}
ons to C
• Range-based for-loops (C++11)
struct BigStruct
{
double array[100];
int last;
};
BigStruct data[100];
// assume int array[30]
for (auto &element: array)
statement
// 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;
}
ons to C
• binary constant
–e.g. int i = 0b101;
• data types
–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)
ons to C
• Bool
bool bValue;
// true (!=0) or false (0)
bool bValue1 = true;
bool bValue2(false);
bool bValue1 = !true;
bool bValue2(!false);
// explicit assignment
// implicit assignment
// bValue1 will have the value 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;
ons to C
• The static_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
spaces
• Defining namespaces
// same as file3.ccp
namespace CppNS
{
double cos(double argInDegrees)
{
...
}
double sin(double argInDegrees)
{
...
}
}
spaces
• Referring to namespaces
#include <file3>
#include <iostream>
#include <cmath>
using namespace std;
// same as file3.ccp
namespace CppNS
{
double cos(double argInDegrees)
{…}
double sin(double argInDegrees)
{…}
}
int main()
{
cout << "The cosine of 60 degrees is: "
<< CppNS::cos(60)
<< ::cos(60); // call the standard std::cos(60) function
}
spaces
• Referring to namespaces
#include <file3>
#include <iostream>
#include <cmath>
using namespace std;
// same as file3.ccp
namespace CppNS
{
double cos(double argInDegrees)
{…}
double sin(double argInDegrees)
{…}
}
int main()
{
using CppNS::cos;
/* ... */
cout << cos(60)
// calls CppNS::cos()
<< ::cos(60);
// call the standard std::cos(60) function
}
spaces
• The standard namespace
–The std namespace is reserved by C++
–The standard defines many entities that are part of the ru
• e.g., cout, cin, cerr
• the templates defined in the Standard Template Library
• the Generic Algorithms
spaces
• Nesting namespaces
#include <file3>
int main()
{
CppNS::value = 0;
CppNS::Virtual::pointer = 0;
}
#include <file3>
using namespace CppNS;
int main()
{
value = 0;
Virtual::pointer = 0;
}
// same as file3.ccp
namespace CppNS
{
int value;
namespace Virtual
{
void *pointer;
}
}
spaces
• Nesting namespaces
#include <file3>
using namespace CppNS;
using namespace Virtual;
int main()
{
value = 0;
pointer = 0;
}
#include <file3>
using namespace CppNS ::Virtual;
int main()
{
CppNS ::value = 0;
pointer = 0;
}
// same as file3.ccp
namespace CppNS
{
int value;
namespace Virtual
{
void *pointer;
}
}
spaces
• 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;
}
spaces
• 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()
{
/* … */
}
}
}
ring
• 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
}
ring
• 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;
swap(sStr1, sStr2);
cout << sStr1 << " " << sStr2 << endl;
sStr1.swap(sStr2);
cout << sStr1 << " " << sStr2 << endl;
// red blue
// blue red
// red blue
ring
• 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("01234567");
// insert substring of sInsert from index [3,7) into sString at index 2
sString.insert(2, sInsert, 3, 4);
// aa3456bbccccbbaa
cout << sString << endl;
}
ring
• 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
ring
• std::string Member functions
– http://en.cppreference.com/w/cpp/string/basic_string
access specified character with bounds checking
clears the contents
inserts characters
removes characters
compares two strings
replaces specified portion of a string
returns a substring
copies characters
find characters in the string
find the last occurrence of a substring
find first occurrence of characters
find last occurrence of characters
/* … */
ring
• std::string Member functions
– http://en.cppreference.com/w/cpp/string/basic_string/at
#include <stdexcept>
#include <iostream>
int main()
{
std::string s("message");
// for capacity
abx
s = "abc";
string size = 3
s.at(2) = 'x';
// ok
string capacity = 7
std::cout << s << '\n';
basic_string::at
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‘; }
}
ring
• 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
stollConvert string to long long
stoull Convert string to unsigned long long
stof Convert string to float
stodConvert 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 = "-10010110001";
int i_bin = std::stoi (str_bin,nullptr,2);
std::cout << str_bin << ": " << i_bin;
// -10010110001: -1201
reams
• 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;
}
reams
• 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>
char buf[10];
cin >> setw(10) >> buf;
/* Any remaining characters will be left in the stream until the next extraction */
reams
• extraction operator (>>)
/*
The one thing that we have omitted to mention so far is that the extraction operator w
*/
char ch;
while (cin >> ch)
input : Hello my name is Omid
cout << ch;
output: HellomynameisOmid
while (cin.get(ch))
cout << ch;
input : Hello my name is Omid
output : Hello my name is Omid
reams
• 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 chara
char strBuf[11];
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 */
reams
• extraction operator (>>)
/* If you need to know how many character were extracted by the last call of getline(),
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);
cout << strBuf << endl;
reams
• 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
reams
• insertion operator (<<)
cout << true << " " << false << endl;
cout.setf(ios::boolalpha);
cout << true << " " << false << endl;
// 0 1
// true false
cout << noboolalpha << true << " " << false << endl;
cout << boolalpha << true << " " << false << endl;
// 0 1
// true false
cout << fixed << endl;
// Use decimal notation for values
cout << setprecision(3) << 123.456 << endl;
// 123.456
cout << setprecision(4) << 123.456 << endl;
// 123.4560
reams
• 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
reams
• insertion operator (<<)
cout << -12345 << endl;
// print default value with no field width
cout << setw(10) << -12345 << endl;
// print default with field width
cout << setw(10) << left << -12345 << endl; // print left justified
cout << setw(10) << right << -12345 << endl;
// print right justified
cout << setw(10) << internal << -12345 << endl; // print internally justified
cout.fill('*');
cout << -12345 << endl;
cout << setw(10) << -12345 << endl;
cout << setw(10) << left << -12345 << endl;
cout << setw(10) << right << -12345 << endl;
cout << setw(10) << internal << -12345 << endl;
-12345
-12345
-12345
-12345
- 12345
-12345
****-12345
-12345****
****-12345
-****12345
reams
• Stream classes for strings
–One of the primary uses of string streams is to buffer outp
#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 << "12345 67.89";
// insert a string of numbers into the stream
string strValue;
int nValue;
os >> strValue;
double dValue;
string strValue2;
os >> nValue >> dValue;
os >> strValue2;
cout << strValue << " - " << strValue2 << endl;
// 12345 - 67.89
reams
•Stream states (Flags)
•Operations on streams may fail for variou
ios::goodbit
Everything is okay (none of the other three conditio
ios::badbit
Some kind of fatal error occurred (eg. the program t
ios::eofbit
The stream has reached the end of a file
ios::failbit
reams
•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
reams
•Stream states - Member function
void state() {
cout << cin.bad() << cin.fail() << cin.eof() << cin.good() << '\n';
}
int main() {
/* Whenever an operation fails, fur
string line;
int x;
// cin.clear();
cin >> x;
// omid 
cin >> line;
// suspended
state();
// 0100
state();
// 0100
cin.clear();
getline(cin, line); // suspended
cin >> line;
// omid
state();
// 0100
state();
// 0001
getline(cin, line); // 
state();
// 0001
}
reams
•Stream states
if (cin)
// if (not cin.fail())
if (cin >> x)
// if (not (cin >> x).fail())
if (getline(cin, str))
// if (not getline(cin, str).fail())
reams
•Input validation
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)
reams
•Input validation
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]))
{
….
}
tice: 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;
}
reams
•File
–ifstream (derived from istream)
• file input
–ofstream (derived from ostream)
• output file
–fstream (derived from iostream).
reams
•File output
#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;
reams
•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;
rence
• http://en.cppreference.com/w/
• http://www.cplusplus.com/reference/