我不会C++，没问题，跟凯哥一起学(四)

作者: violet小咔咔 | 来源:发表于2018-12-26 21:34 被阅读0次

前言

懂C的人说这些太简单我不会C++，没问题，跟凯哥一起学(三)，但是有些东西是其他人必须过一眼的，这样才可以知道怎么读代码，怎么check question , 怎么去google.好了接下来我们顺着撸，过于基础的会直接略过。

操作符

数学运算操作符（+、-、*、/、%、++、--）
关系运算操作符（==、!=、>、>、>=、<=）
逻辑运算操作符（&&、||、!）
位运算操作符 (与、或、非和异或的真值表)
赋值运算操作符
复合运算操作符

位运算操作符

以上6点大部分比较简单和java差不多，这里不再累赘：

A = 0011 1100
B = 0000 1101
A&B = 0000 1100
A|B = 0011 1101
`A^B` = 0011 0001
~A  = 1100 0011

位运算符.png

复合运算符

复合运算符.png

循环的类型

循环类型.png

无穷循环

如果循环条件无法变为 false 的话，那么该训话那就是无穷循环。for 循环就是实现无穷循环。for 循环条件中的三个表达式并不是必须的，所以只要将条件判断语句置空就可以实现无穷循环。当条件判断语句置空后，就默认是 true. 程序员也可以保留初始化和递增表达式，但是 C++ 工程师一般都是使用 for(;;)来表达无穷循环。

#include <iostream>
using namespace std;
int main () {
for( ; ; )
   {
  printf("This loop will run forever.\n");
}
return 0; }
注意:可以通过 Ctrl + C 的方式来终止无穷循环。

定义一个函数

C++ 函数的定义的一般形式如下所示:
return_type function_name( parameter list )
{
   body of the function
}
返回值类型: 一个函数可能返回一个值。 return-type 是该函数返回的值的数据类型。有些函数执行所需 的操作不返回一个值，在这种情况下，return-type 是关键字 void.
• 函数名称: 这是函数实际的名字。函数名称和参数列表一起构成了这个函数的签名。
• 参数: 一个参数就像一个占位符。当调用参数时，你将把值传递给该参数。这个值称为实际参数或参数。参 数列表是指一个函数的类型，顺序和参数的数目。参数是可选的，那就是指，一个函数可能不包含参数。
• 函数体: 函数体包含定义函数做什么的一系列语句。

当你在一个源文件中定义了一个函数并且在另一个文件中调用了该函数时，函数的声明是必需的。在这种情况下，你应该在调用该函数的文件的顶部声明这个函数。

函数参数

如果一个函数要使用参数，它必须声明接受参数值的变量。这些变量被称为函数的形参。像其他本地变量一样，这些形参在函数中，在进入函数时创建，在退出函数时销毁。当调用函数时，这里有两种方式可以将参数传递给函数

参数注意事项.png

详细的 C++ 数组

数组.png
C++ 提供了以下两种类型的字符串表示形式:
• C 样式字符串
• 用标准 C++ 介绍的标准字符串类型

C 样式字符串

C 样式字符串源于 C 语言，在 C++ 中仍然被支持。这个串实际是一个字符的一维数组，这个数组以一个空字符 ‘\0’ 结束。因此以 null 结尾的字符串包含由字符组成的字符串，此字符串后跟着一个 null。
接下来声明和初始化创建一个字符串，这个字符串组成一个单词 "hello"。为了包含数组末尾的空字符，包含该字符串的字符数组的大小应该比单词 "hello" 中的字符的数目多一个。

char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};

如果你遵循数组初始化的规则，你可以像下面一样书写上面的语句:

char greeting[] = "Hello";

c++数组内存演示.png

实际上，你不需要在字符串常量的末尾放置一个空字符。 C++ 编译器在初始化数组时自动在串的末尾放置一个 '\0'。让我们尝试打印上述字符串:

#include <iostream>
using namespace std;
int main () {
   char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
   cout << "Greeting message: ";
   cout << greeting << endl;
return 0; }
当上述代码被编译执行时，它将产生如下结果:
Greeting message: Hello

指针

如你所知，每个变量有一个内存位置，每个内存位置都有它的地址定义，这个地址定义可以使用表示内存中地址的和运算符 (&) 进行访问。下面我们将打印定义的变量的地址:

#include <iostream>
using namespace std;
int main () {
   int  var1;
   char var2[10];
   cout << "Address of var1 variable: ";
   cout << &var1 << endl;
   cout << "Address of var2 variable: ";
   cout << &var2 << endl;
return 0; }
当上述代码被编译执行时，它将产生如下结果:
Address of var1 variable: 0xbfebd5c0
Address of var2 variable: 0xbfebd5b6

指针是一个变量，它的值是另一个变量的地址。像任何变量或常量一样，你必须在使用它之前声明一个指针。指针变量声明的一般形式为:

type *var-name;

在这里，type 是指针的基类型;它必须是一个有效的 C++ 类型，var-name 是指针变量的名称。用来声明一个指针的星号与你用于乘法的星号是一样的。然而，在这个语句中，这个星号用来指定一个变量作为一个指针。以下是有效的指针声明:

int*ip;// pointer to an integer
double *dp;// pointer to a double
float  *fp;// pointer to a float
char   *ch // pointer to character

所有指针的值的实际的数据类型，或者是整数，浮点数，字符或者是其他，同样的一个长十六进制数表示一个内
存地址。不同的数据类型的指针之间的唯一区别在于指针指向的变量或常量的数据类型。

在 C++ 中使用指针

这里有几个我们将非常频繁的使用指针的重要的操作。
(a) 我们定义一个指针变量;
(b) 将一个变量的地址分配给指针;
(c) 最后使用在指针变量中的地址来访问这个值。
这是通过使用一元运算符 * 完成的，返回位于通过运算符指定地址的变量的值。以下示例使用这些操作:

#include <iostream>
using namespace std;
int main () {
   int  var = 20;   // actual variable declaration.
   int  *ip;// pointer variable
   ip = &var;   // store address of var in pointer variable
   cout << "Value of var variable: ";
   cout << var << endl;
   // print the address stored in ip pointer variable
   cout << "Address stored in ip variable: ";
   cout << ip << endl;
// access the value at the address available in pointer
cout << "Value of *ip variable: ";
   cout << *ip << endl;
return 0; }
当上述代码被编译执行时，它将产生如下结果:
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20

指针的概念.png

引用

引用变量是一个别名，即已经存在的变量的另一个名称(引用就是某一个变量的别名)。一旦用一个变量初始化
引用，变量名称和引用名称都可以用来指示变量。

C++ 引用 VS 指针

引用与指针非常容易混淆，但引用和指针有三个主要区别:
• 空引用不可能存在。你必须始终能够假定一个引用被连接到一个合法的存储块。
• 一旦一个引用被初始化为一个对象，它就不能改变去指示另一个对象。指针可以随时改变指向另一个不同的对象。
• 引用必须在它被创建时就初始化。指针可以在任何时候初始化。

在 c++ 中创建引用

考虑到一个变量名是一个附加到该变量在内存中的位置的标签。你可以认为一个引用是附加到该内存位置的第二个标签。因此,您可以通过原始变量名或引用来访问变量的内容。例如，我们假设有下面的例子:

int i = 17;

我们可以为 i 声明引用变量，如下所示。

int& r = i;

在这些声明中将 & 理解为引用(reference)。因此，第一个声明理解为 “ r 是一个整数引用，初始化为 i ” 和第二声明理解为 “ s 是一个双引用，初始化为 d ”。下面的例子使用了 int 和 double 引用:

#include <iostream>
using namespace std;
int main () {
   // declare simple variables
   inti;
   double d;
// declare reference variables
   int&r = i;
   double& s = d;
   i = 5;
   cout << "Value of i : " << i << endl;
   cout << "Value of i reference : " << r  << endl;
   d = 11.7;
   cout << "Value of d : " << d << endl;
   cout << "Value of d reference : " << s  << endl;
return 0; }
将上面的代码放在一起编译、执行，执行结果如下 :
Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7

引用通常用于函数参数列表和函数返回值。以下是与 c++ 引用有关的两个重要的方面，一个 c++ 程序员应该明确了解:
1、引用作为参数，c++ 支持引用作为函数参数传递，它比直接传递参数更安全。
2、引用作为返回值，可以从一个 c++ 函数返回引用，就像返回任何其他数据类型。

I/O 库头文件

头文件：#include<iostream>
这个头文件定义了 cin、cout、cerr 和 clog 对象，它们分别对应于标准输入流，标准输出流，无缓 冲标准错误流和有缓冲标准错误流。
头文件：#include<iomanip>
这个头文件声明了用于执行格式化 I/O 操作的一系列服务，即所谓的参数化流操作，如 setw 和 set precision。
头文件：#include<fstream>
这个头文件声明了基于用户控制的文件处理服务。我们将在文件和流相关的章节更详细讨论关于它的 内容。

标准输出流

预定义的对象 cout 是 ostream 类的一个实例。cout 对象通常连接到标准输出设备，一般是显示屏。cout 和流插入运算符联合使用，流插入运算符写为 << ，即两个表示小于的符号，如以下示例所示。

#include <iostream>
using namespace std;
int main( ) {
   char str[] = "Hello C++";
   cout << "Value of str is : " << str << endl;
}
编译和执行上面的代码，运行结果如下:
Value of str is : Hello C++

C++ 编译器也决定了输出的变量数据类型并选择适当的流插入运算符来显示值。 << 操作符重载了多种输出数据项(包括各种内置类型:整数、浮点数、双精度浮点数、字符串和指针类型的值)。
插入运算符 << 在一个语句中可能不止一次被使用，如上所示，endl 写在结束的时候用于添加一个新行

标准输入流

预定义对象 cin 是 istream 类的一个实例。cin 对象通常用于标准输入设备，一般是键盘。cin 和流提取运算符联合使用，流提取符号写为 >> 即两个表示大于的符号，如以下示例所示。

#include <iostream>
using namespace std;
int main( ) {
   char name[50];
   cout << "Please enter your name: ";
   cin >> name;
   cout << "Your name is: " << name << endl;
}
编译和执行上面的代码，它会提示输入一个名称。输入一个值，然后回车，运行结果如下:
Please enter your name: cplusplus
Your name is: cplusplus

C++ 编译器也决定输入值的数据类型和选择适当的流提取运算符提取值并将其存储在给定的变量。流提取操作符 >> 可以在一个声明中不止一次使用。请求多个数据时，可采用以下书写形式:

cin >> name >> age;
上述表达式等价于下面两个声明语句:
cin >> name;
cin >> age;

标准错误流

预定义对象 cerr 是 ostream 类的一个实例。cerr 对象通常附加到标准错误设备，这一般也是一个显示屏，但对象 cerr 是无缓存的，每当有流插入到 cerr 会导致其输出立即出现。
cerr 也与流插入操作符一起使用，如以下示例所示。

#include <iostream>
using namespace std;
int main( ) {
   char str[] = "Unable to read....";
   cerr << "Error message : " << str << endl;
}
编译和执行上面的代码，运行结果如下:
Error message : Unable to read....

标准日志流

预定义对象 clog 是 ostream 类的一个实例。clog 对象通常附加到标准错误设备，这一般也是一个显示屏，但对象 clog 是有缓冲的。这意味着每个插入的 clog 会暂存在缓冲区中，直到缓冲区满或者缓冲区刷新才会产生一次输出。
clog 也与流插入操作符一起使用，如以下示例所示。

#include <iostream>
using namespace std;
int main( ) {
   char str[] = "Unable to read....";
   clog << "Error message : " << str << endl;
}
编译和执行上面的代码，运行结果如下:
Error message : Unable to read....

在这些小例子中，你可能无法看出 cout,cerr,clog 的区别，但在编写、执行大项目时，差异就变得显而易见了。所以这是很好的应用实践:使用 cerr 流显示错误消息，而使用 clog 显示其他日志信息。