Escape Sequences#

In addition, C++11 supports raw string literals, which are suitable for situations where many characters need to be escaped. They must begin with R, and the string content must be placed in parentheses, with an additional pair of double quotes outside the parentheses. The following code outputs the string literal “c:\Windows”.

1
cout << R"(c:\Windows\)";

Formatting Numbers with Decimals#

Link

Enumeration Types (Optional Reading)#

An enumeration type is a type whose values are defined by a set of constants of type int. An enumeration type is like a list containing a set of declared constants. Within an enumeration type, two or more named constants may take the same int value. If no values are specified, the identifiers in an enumeration type are automatically assigned a set of consecutive values, with the first being 0 and each subsequent constant being the previous value plus 1 - unless one or more enumeration constants are explicitly assigned values.

1
enum Direction { NORTH = 0, SOUTH = 1, EAST = 2, WEST = 3 }
2
enum Direction { NORTH, SOUTH, EAST, WEST }
3
//The two statements above are equivalent.

C++11 introduces a new kind of enumeration, called a strongly typed enumeration or enumeration class. To define a strongly typed enumeration, just add the keyword class after enum.

The Increment and Decrement Operators Revisited#

If ++ comes before a variable, the variable is incremented first, then the value is returned; if ++ comes after a variable, the value is returned first, then the variable is incremented.

Some Predefined Functions#

Type Casting#

1
static_cast<TargetType>(expression);
2
// int to double
3
static_cast<double>(3);
4

5
//the old-style form of type casting
6
TypeName(expression);
7
double(3);
8

9
//Although it's said to prefer the first form, the second one types fewer characters, so...

Another Form of Function Declaration#

Function declarations do not have to list the parameter names. The following two declarations are equivalent:

1
double abc(int a, double b);
2
double abc(int, double);

But you should stick with the first form to ensure readability.

Call-by-Reference Parameters#

Sometimes they work wonders and are super comfortable to use.

1
// normal (call-by-value) function declaration
2
int abc(int a);
3
// call-by-reference function declaration
4
int abc(int& a);

File I/O#

1
using namespace std;
2
ifstream inStream;
3
ofstream outStream;
4

5
inStream.open("infile.dat");
6
outStream.open("outfile.dat");
7

8
inStream.close();
9
outStream.close();

1
ofstream fout;
2
fout.open("data.txt",ios::app);

Formatting Output with Stream Functions#

Member functions of every output stream (partial):

The formatting flags of setf():

Any flag can be canceled with unsetf().

Manipulators#

These feel pretty redundant…

String I/O#

put(),get(),putback()

1
void newLine(istream& inStream = cin);

1
double next, sum = 0;
2
int count = 0;
3
while (inStream >> next)
4
{
5
    sum += next;
6
    count++;
7
}

C++11 Range-Based for Loops#

A new kind of for loop in C++11, used to quickly iterate over array elements.

1
int arr[]={1,2,3,4,5};
2
for(auto i : arr)
3
    cout<<i;

You can even do this

1
int arr[]={1,2,3,4,5};
2
for(int& i : arr)
3
    i++;
4
for(int i : arr)
5
    cout<<i;

An Entire Array as a Function Argument#

It’s basically the same as using call-by-reference parameters. To prevent accidental modification, it’s common to use const.

Predefined C-String Functions#

If you need to check the maximum capacity that Target_string can store, you can use functions with a trailing _s, such as strcpy_s.

The Standard string Class#

1
istream& getline(istream& ins, string& strVar, char delimiter);
2
istream& getline(istream& ins, string& strVar);

1
aCString = stringVariable.c_str();  //illegal

Vectors#

One of my favorite features. It deserves a name, let’s give it one. Who doesn’t like an advanced array that can grow automatically and instantly tells you its length

Basic Memory Management#

Remember to delete after you new. Also, after deleting, remember to point the dangling pointer to nullptr.