#include <iostream>
int main()
{
//int apple_count{ 15.5 }; /*此行会导致编译错误。错误类型是narrowing conversion。*/
int apple_count{ 15 }; /*第一种赋值形式；The braces enclosing the initial value are called a braced initializer.这种赋值形式自C++11开始引入。commonly referred to as uniform initialization. */
int orange_count( 5 ); /*第二种赋值形式；Functional notation*/
int total_fruit = apple_count + orange_count; //第三种赋值形式； assignment notation；initial value for a variable can be an expression*/
std::cout << total_fruit <<std::endl; /*输出结果为20*/
}#include <iostream>
int main()
{
int counter_01 { 0 }; // counter_01 initiated to 0
std::cout << counter_01 << std::endl;
int counter_02{}; /*counter_02 initiated to 0 as well;Zero initialization works for any fundamental type.For all fundamental numeric types, an empty braced initializer is always assumed to contain the number zero.*/
std::cout << counter_02 <<std::endl;
}#include <iostream>
int main()
{
int written_with_single_quote = 1'234;/*since C++14, you can use the single quote character, ', to make numeric
literals more readable. */
std::cout << written_with_single_quote<< std::endl;//输出结果为数字 1234
int hex_num{ 0x4D2 };//hexadecimal literal is prefixed with 0x or 0X
std::cout << hex_num << std::endl;//输出结果为十进制数1234
int octal_num{ 02322 };//hexadecimal literal is prefixed with 0x or 0X
std::cout << octal_num << std::endl;//输出结果为十进制数1234
int bi_lit{ 0B100'1101'0010 };/*Binary literals were introduced by the C++14 standard. You write a binary integer literal as a sequence of binary digits(0 or 1) prefixed by either 0b or 0B. You can use a single quote as a separator in any integer literal to make it easier to read. */
std::cout << bi_lit;//输出结果为十进制数1234
}
It is defined such that, for all integers x and y, (x / y) * y + (x % y) equals x.
The result of both the division and modulus operator is undefined when the right operand is zero—what’ll happen depends, in other words, on your compiler and computer architecture.
#include <iostream>
int main()
{
int positive_num = 345;
int negtive_num = -positive_num; /*The minus sign is a unary operator and it negates the value of a variable.*/
std::cout << negtive_num<< std::endl;//输出结果为数字 -345;
//int denominator = 0;//denominator是分母的意思
//int div_by_zero = positive_num / denominator;//这个statement可以编译通过，但是运行程序时会导致程序出错，中断。
}#include <iostream>
/* you cannot read and store spaces using the >> operator for a stream, even when you store them in variables that store characters.*/
/*When the execution sequence runs beyond the end of main(), it is equivalent to executing return 0.*/
int main()
{
int a, b, c;
std::cout << "Enter three numbers seperated by spaces.";
std::cin >> a >> b >> c;
std::cout << a << std::endl << b << std::endl << c << std::endl;
char d, e, f;
std::cout << "Enter three numbers seperated by spaces.";
std::cin >> d >> e >> f;
std::cout << d << e << f;
}#include <iostream>
int main()
{
int x{ 1 }, y{ 10 };
x *= y + 1;//assignment operator *= 的优先级小于 +
std::cout << x << std::endl;//输出结果为11
x = 1;
y = 10;
x = x * (y + 1);
std::cout << x << std::endl;//输出结果也是11
}You can eliminate the need to qualify a name with the namespace name in a source file with a using declaration. Here’s an
example:
using std::cout;
This tells the compiler that when you write cout, it should be interpreted as std::cout. With this declaration before the main() function definition, you can write cout instead of std::cout, which saves typing and makes the code look a little less cluttered.
#include <iostream>
using std::cout;
int main()
{
char x;
cout << "Enter a character" << std::endl;//此行编译无问题
cin >> x;//此行会导致编译错误，identifier "cin" is undefined。需要在前面加上std::
}A using directive imports all the names from a namespace. Here’s how you could use any name from the std namespace without the need to qualify it:
using namespace std; // Make all names in std available without qualification
With this at the beginning of a source file, you don’t have to qualify any name that is defined in the std namespace. At first sight this seems an attractive idea. The problem is it defeats a major reason for having namespaces. It is unlikely that you know all the names that are defined in std, and with this using directive you have increased the probability of accidentally using a name from std.
We recommend that you make use of using directives only when there’s a good reason to do so.
#include <iostream>
using namespace std; // Make all names in std available without qualification
int main()
{
char x;
cout << "Enter a character" << endl;//此行编译无问题
cin >> x;//此行编译无问题
}#include <iostream>
int main()
{
int count{5};
int total;
total = count++ + 6;
std::cout << total<< std::endl;//输出11
std::cout << count;//输出6
}You cannot use the unsigned or signed modifiers with floating-point types; floating-point types are always signed.
/* float literals have f (or F) appended and
long double literals have L (or l) appended. Floating-point literals without a suffix are of type double.
A floating-point literal includes either a decimal point or an exponent, or both; a numeric literal with neither
is an integer.*/
#include <iostream>
int main()
{
float pi{ 3.1415926f }; // Ratio of circle circumference to diameter
double inches_to_mm{ 25.4 };
long double root_of_2{ 1.4142135623730950488L }; // Square root of 2
}#include <iostream>
#include <limits>
#include <cmath>
int main()
{
double a{ 1.5 }, b{}, c{};
std::cout << ::isinf(a / b); //输出1
std::cout << ::isnan(b /c ); //输出1
}#include <iostream>
#include <limits>
#include <cmath>
int main()
{
std::cout << ceil(2.5) << std::endl;//输出3；Computes a floating-point value that is the smallest integer greater than or equal to arg
std::cout << floor(2.5) << std::endl;//输出2；Computes a floating-point value that is the largest integer less than or equal to arg
std::cout << std::round(-1.5f) << std::endl;//输出-2；Halfway cases are rounded away from zero.
}The area of a circle is given by the formula πr2, where r is the radius.
#include <iostream>
#include <iomanip>
int main()
{
int a{ 16 }, b{ 66 };
std::cout << std::setbase(16) << std::showbase << "a = " << a << " b = " << b << std::endl;//以16进制显示
std::cout << std::setbase(8) << std::showbase << "a = " << a << " b = " << b << std::endl;//以8进制显示
std::cout << std::setbase(10) << std::showbase << "a = " << a << " b = " << b << std::endl;//以10进制显示
}With each operation with operands of different types, the compiler chooses the operand with the type
that has the more limited range of values as the one to be converted to the type of the other. In effect, it ranks
the types in the following sequence, from high to low:
1. long double 2. double 3. float 4. unsigned long long 5. long long 6. unsigned long 7. long 8. unsigned int 9. int
#include <iostream>
int main()
{
unsigned int x{ 20u };
int y{ 30 };
std::cout << x - y << std::endl;
/*You might expect the output to be -10, but it isn’t. The output is 4294967286, not -10!
This is because the value of y is converted to unsigned int to match the type of x, so the result of the subtraction is an unsigned integer value.
And -10 cannot be represented by an unsigned type. For unsigned integer types, going below zero always wraps around to the largest possible integer value.
That is, for a 32-bit unsigned int type, -1 becomes 2的32次方 - 1 or 4294967295. This of course means that -10 indeed becomes 2的32次方 - 10, or 4294967286.*/
}#include <iostream>
int main()
{
double value1{ 10.9 };
double value2{ 15.9 };
int tot = value1 + value2;
int whole_number{ static_cast<int>(value1) + static_cast<int>(value2) };/*The static_cast keyword reflects the fact that the cast is checked statically, that is, when the code
is compiled.
Note that as with integer division, casting from a floating-point type to an integral type uses truncation.
That is, it simply discards the entire fractional part of the floating-point number.*/
std::cout << whole_number << std::endl;
}#include <iostream>
int main()
{
std::cout << "Maximum value of type double is " << std::numeric_limits<double>::max()<< std::endl;//输出double数据类型能代表的最大值
std::cout << "Minimum value of type signed int is " << std::numeric_limits<signed int>::min()<< std::endl;//输出signed int数据类型能代表的最小值
std::cout << "Number of bits of type signed int(excluding the sign bit) is " << std::numeric_limits<signed int>::digits;//输出结果为31；For signed integer types, you’ll get the number of bits in the value, that is, excluding the sign bit.
}/*Type wchar_t is a fundamental type that can store all members of the largest extended character set
that’s supported by an implementation.
There are also escape sequences that specify a character by its code expressed as either an octal or a
hexadecimal value.The escape sequence for an octal character code is one to three octal digits preceded
by a backslash.The escape sequence for a hexadecimal character code is one or more hexadecimal digits
preceded by \x.You write either form between single quotes when you want to define a character literal.*/
#include <iostream>
#include <iomanip>
int main()
{
wchar_t wch{ L'李' };/*wide-character literal is prefixed with L*/
std::cout << std::setbase(16) << std::showbase << wch<< std::endl;/*输出汉字李的16进制Unicode编码 0X674e;*/
}Constants of any kind are called literals. All literals have a type.
Type wchar_t stores a wide character and occupies either two or four bytes, depending on your compiler. Types char16_t and char32_t may be better for handling Unicode characters in a cross-platform manner.
//设定输出数字显示的位数
#include <iostream>
#include <iomanip>
int main()
{
const double pi{ 3.141592653589793238 }; // Initialize constant variable
int precision;
std::cout << "Please enter the desired precision of pi (significant figures):";
std::cin >> precision;
std::cout << std::setprecision(precision);
std::cout << "\npi now is " << pi << std::endl;
}
/*the integer between the parentheses in setprecision() specifies the output precision for floating-point values, which
is the total number of digits before and after the decimal point. You can make the parameter specify the
number of digits after the decimal point—the number of decimal places in other words—by setting the
mode as fixed. */
#include <iostream>
#include<iomanip>
int main()
{
std::cout << std::setprecision(1) << 3.1415926 << std::endl;//输出3
std::cout << std::fixed << std::setprecision(1) << 3.1415926 << std::endl;//输出3.1
}//不借助function,直接用基本的算数运算符计算找出两个正整数中哪个较大，哪个较小
// Exercise 2-6. Finding the largest of two integers without comparing them.
// The expressions depend on the fact that smaller/larger will be 0 with integer arithmetic
// whereas larger/smaller will be some positive non-zero integer.
#include <iostream>
int main()
{
long a{};
long b{};
std::cout << "Enter a positive integer: ";
std::cin >> a;
std::cout << "Enter another different positive integer: ";
std::cin >> b;
// The trick is to find arithmetic expressions for each of the larger
// and the smaller of the two integers
const long larger{ (a * (a / b) + b * (b / a)) / (a / b + b / a) };
const long smaller{ (b * (a / b) + a * (b / a)) / (a / b + b / a) };
std::cout << "The larger integer is " << larger << ".\n"
<< "The smaller integer is " << smaller << '.' << std::endl;
}