xzw码农转型笔记_I - cpp速通

Tavior

昨天初步敲定了一下在学习MPI之前需要疏通的计算机前置知识，计划接下来的几个月集中学习一下计算机编程相关的基础和进阶课程，为具备独立开发并行计算程序打点基础，并且愉快地决定在鸽舍更新我的学习笔记ww

学习路线（并不太小的小目标）：
o1. C++熟悉：RUNOOB教程速通https://www.runoob.com/cplusplus/cpp-tutorial.html
o2. 《深入理解计算机系统》
o3. 《计算机网络：自顶向下方法》
o4. 《数据结构、算法与应用：C++语言描述》（只看链表部分）
o5. 选读：《算法导论》，《离散数学》
在此之后，就可以开始读《基于MPI的大数据高性能计算导论》了（只读MPI部分）

Tavior

Section 1 编译，执行C++程序
Helloworld程序中的一些问题：

#include <iostream>
using namespace std;
int main()
{
    cout << "Hello world" << endl;
    return 0;
}

其中endl和'\n'是一样的效果，后面的<< endl不写也是可以编译成功的
另外vscode的调试和cmake真是折腾人，windows下调试一直不行。。。。

关于Helloworld的几个小注释：

a. namespace和std是啥

std:: 是个名称空间标示符，C++标准库中的函数或者对象都是在命名空间std中定义的，所以我们要使用标准函数库中的函数或对象都要使用std来限定。
对象cout是标准函数库所提供的对象，而标准库在名字空间中被指定为std，所以在使用cout的时候要加上std::。这样编译器就会明白我们调用的cout是名字空间std中的cout。
可以直接使用using namespace **std来代替std::cout和std::endl前面的std::（这里就是这种用法）。真正的开发过程中尽量避免使用这种方法，否则可能会引起命名空间污染，函数名重复
若上述两种方法都不用，那么编译器无法判定cout和endl的定义，就会报错
使用非标准库文件iostream.h时不用写

b. 如何理解Cpp的“流”？

C++ 的标准类库中，将用于进行数据输入输出的类统称为“流类”。cin 是流类 istream 的对象，cout 是流类 ostream 的对象。要使用流类，需要在程序中包含 iostream 头文件。
更进一步的内容在后面的“C++文件和流”文档中叙述

c. endl与\n

输出换行时，这两个命令都是可以的，但是endl会刷新缓冲区，使得栈中数据刷新，在没有必要刷新输出流的时候尽量用\n换行
至于什么时候需要刷新缓冲，留一个坑，以后应该会遇到？

d.C++中的.h与.cpp文件

.h中存放类的声明，函数原型
.cpp存放函数体（定义）

e.include <*>与include "*"

两者优先级不同，<*>优先在系统目录中寻找头文件，如果没有再在当前目录找；而"*"正好相反，优先在当前目录下找

f. include头文件的时候何时加.h

所有自己写的头文件都要加.h后缀
现行标准的C++头文件没有.h扩展名，而新的C++标准库为了统一以前的C标准库，将原来c的标准库也放入了std名字空间，并把原来的C标准库去掉了.h后缀，前面加上字母“c”，例如stdio.h就变成了cstdio。
对于C标准库，有两种使用方法，一种是用老的.h形式，例如stdio.h直接包含就可以了；另一种就是用C++的统一形式，例如cstdio，和C++标准库一样，包含了以后还要加上using namespace std;才能使用——经测试，至少在我的终端上使用cstdio时写与不写std::printf都可以正常编译运行。

g. main函数的数据类型

标准规范中规定main函数的返回值为int，一般约定返回0值时代表正常，其他值为错误号
void main并不推荐，且g++编译器要求main函数的返回值为int型
int main(void)和int main()在C语言中有区别，在C++中等效

小毛龙

Tavior c. endl与\n
输出换行时，这两个命令都是可以的，但是endl会刷新缓冲区，使得栈中数据刷新，在没有必要刷新输出流的时候尽量用\n换行
至于什么时候需要刷新缓冲，留一个坑，以后应该会遇到？

其实我在想输出缓冲区来说的话问题比较像“什么时候不该刷新缓冲”...我目前为止是习惯用到的时候随手刷一刷防止里面有奇形怪状的东西。

但这个问题感觉蛮有意义的，蹲一个解答。

Tavior

Section 2 基本语法：
C++程序可以定义为对象的集合，他们通过调用彼此的方法进行交互。（这个应该是面向对象编程的概念）

对象(object)：对象具有状态和行为，是类的实例
类(class)：描述对象行为/状态的模板/蓝图
方法：一个方法表示一种行为（？不太懂这句话），一个类可以包含多个方法，可以写入逻辑、操作数据以及执行所有的动作
即时变量：每个对象都具有独特的即时变量，对象的状态是由这些即时变量的值创建的

C++标识符：用来标识变量、函数、类、模块或者其他自定义项目的名称。

三元字符：不太常见，以前用来表示键盘上没有的字符，现在应该没有使用了

空格：只包含空格或者注释的行，编译器会完全忽略

Tavior

Section 3：数据类型

C++的数据类型和C语言一致，可以include<limits>中的函数sizeof(*)读取当前机器上不同类型的字节数
可用typedef为一个已有的类型取一个新名称（应该没有什么用处）
几点说明：
- typedef可以声明类型名（已有的），但不可以定义变量
- 在不同源文件中用到同一类型的数据时，常用其声明一些数据类型，放在单独的头文件中（暂时没看到用途）
- 与#define的区别：
  - #define发生在编译之前，只是简单机械字符替换，不做检查
  - typedef发生在编译阶段，会做类型检查（比如把unsigned int typedef成UINT之后给一个UINT变量赋值为"abc"编译器会报错）
  - typedef常与struct结合使用（？好奇）

枚举类型：如果一个变量只有几种可能的值，则可以定义为enumeration类型，其定义方式如下

#include<iostream>
using namespace std;
//枚举类型可以在main函数内或外定义

enum color {            //color为枚举名，内包含若干整型常数的标识符
    red,                //整型常数默认从0开始赋值，后一个比前一个大1
    green = 0,          //也可以强行为标识符常量赋值，这样之后的变量也是比前一个大1
                        //不同标识符可以有相同的值（不推荐这么做）
    blue                //最后一个变量没有逗号
} c;                    //c为变量名，这个c就只能被赋值为red,green,blue中的一个

int main()
{
    cout << red <<endl;     //输出0
    cout << green <<endl;   //输出0
    cout << blue <<endl;    //输出1

//green = 5;            //不可以这么做，green是在color实体内的变量，在实体外无法更改
c = green;              
switch (c)
{
case red:
    cout << "red" << endl;   //red和green的标识符一致，在目前的设置下会输出red 
    break;
/*
case green:                 //由于green和red的值一致，重复条件值会使得switch函数报错
    cout << "green" << endl;
    break;
*/
case blue:
    cout << "blue" << endl;
    break;
default:
    cout << "input error" << endl;
    break;
}

//c = 1;                //会报错，虽然blue的值也是1，但是不能将int值赋给color类型的实体

return 0;
}

Tavior

Section 4：变量类型

基本变量
- bool变量：一个字节，存储0(false)或者1(true)
- char变量：通常是一个字节(8位)
- int变量：一般是4个字节，第一位为符号
- float变量：一般是4个字节，1位符号，8位指数，23位小数
- double变量：一般是8个字节，1位符号，11位指数，52位小数
- void：缺失类型
变量声明
为了方便编译器编译时明确各个变量的意义
使用多个文件编译时，只需要（也只能够）在某一个文件/函数/代码块中定义变量，在其他的文件中用extern声明该变量就可以使用了（可以多次声明）
声明外部变量时不能进行初始化，因为声明不会为变量开辟内存空间——只有定义变量时才能同时对变量初始化
编译是从上往下的，调用的函数和变量如果没有定义在该函数上方，则需要声明
左值和右值
指向内存位置的表达式为左值(lvalue)，可以出现在赋值号(=)的左右两侧
存储在内存中某些地址的数值为右值(rvalue)，只能出现在赋值号的右侧

自动转换和强制转换

参与运算的类型不同，则会先转换为同一类型再计算，转换按照数据长度增加的方向进行，以保证精度不降低
若参与运算的两种类型字节数相同，一种有符号，一种无符号，则转换为无符号类型之后计算
所有的浮点数都是以双精度进行
char和short型计算时会先转换为Int型

赋值运算时，右值会转换为左值的类型，如果右值比左值数据类型长，就会丢失精度

#include <iostream>
using namespace std;
int main()
{
ounsigned int a = 1;
oint b = -2;
ounsigned int c = 3;
o
oint value;
o
ocout << a+b <<endl;定义中声明的变量——形式参数


在所有函数外部声明的变量——全局变量



局域变量：只能被该函数/代码块内部的语句使用

全局变量：通常定义于程序头部（或者.h文件内），全局变量可以被任何函数访问

局域变量和全局变量的名称可以相同，但在函数内局域变量的值会覆盖全局变量的值
#include<iostream>
using namespace std;

int global = 0;             //全局变量
int Plus(int x, int y);     //调用前必须声明，否则报错

int main()
{
    int a, b;
    a = 10;
    b = 20;
    {
        int b = 100;                        //当作用域不同时，可以定义重名的变量
                                            //作用域小的变量值会临时覆盖作用域大的
        cout << "b = " << b << endl;        //输出100
    }
    cout << "b = " << b << endl;            //输出20

//注意以下两者表达的不同，第一组是在for循环的代码块内临时定义了一个同名变量a
for(int a=0; a<1; a++)
{
    cout << "a = " << a << endl;        //输出0
}
cout << "a = " << a << endl;            //输出10
//第二组是直接使用main函数下的变量a
for(a=0; a<1; a++)
{
    cout << "a = " << a << endl;        //输出0
}
cout << "a = " << a << endl;            //输出1

//函数内可以修改全局变量的值
cout << "global = " << global << endl;  //输出0
Plus(a,b);
cout << "global = " << global << endl;  //输出21

return 0;
}

int Plus(int x, int y)
{
    global = x + y;
    return 0;
}

静态变量

 储存在静态数据区的变量在程序刚开始运行时就完成唯一一次初始化，有两种变量存储在静态存储区：
 全局变量
 static变量：可以控制变量的可见范围——若static局部变量在函数内定义，其生存周期为整个程序，但是它的作用于依然是该函数内部，退出该函数后，变量继续存在，但是不能使用它。
 注意！static的意思并不是说这个变量不可修改，而是其在内存中储存在静态存储区，和全局变量存储在一起
 静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。
#include<iostream>
using namespace std;

int count = 1;      //全局变量

int function()
{
    static int count = 3;   //在第一次进入该函数的时候，这个变量初始化为3
                            //整个程序运行周期中，只执行一次初始化
                            //之后再访问程序时该变量是前一次操作的静态值
    return count--;         //每运行一次程序，count减1
}

int main()
{
    cout << "global     " << "local static" << endl;
    for(; count<=3; ++count)
    {
        cout << count << "          " << function() << endl;
    }
    //输出结果为
    /*
        1   3
        2   2
        3   1
    */
    return 0;
}



            
                    
                                Tavior
                
                    Section 6：常量

在程序执行期间不会改变的值称为常量

普通的数字（不同进制）、字符、字符串以及布尔值（true, false）都是常量

有两种定义常量的方法
使用#define预处理器——字符替换，没有数据类型的区别和安全检查，不会分配变量内存，不能作为参数传递给函数，可以用#undef取消宏定义
使用const关键字（和static不要弄混！）——在编译阶段会进行安全检查，会分配内存，类似于只读数据，不可取消

这两者都只能在声明的同时定义常量的值

编程中，常用全大写标注常量。
runoob上面关于#define和const两者定义范围的问题，似乎#define会根据定义的内容自动匹配合适的类型（如double，int，long long int），而const定义需要自己手动检查定义
#include<cstdio>
#include<iostream>
#include <inttypes.h>
#define MAX_1 10000000000       //用#define指令在预编译阶段替换，可以放在函数内
//#define后面不带分号

int main()
{
    const long long int MAX_2 = 10000000000;   //用const的形式定义常量
                                //必须在定义的同时初始化，否则报错
    /* 以下初始化常量的方式是错误的，常量一经定义就无法修改
    *  const double MAX_2;
    *  MAX_2 = 10000000000;
    */
   

printf("%lld\n", MAX_1);    //编译器报警，原因是%lld是C99标准中的输出，但输出的值正确
//printf("%d\n", MAX_1);    //输出格式不匹配会直接报错，无法通过编译
std::cout << MAX_1 << '\n'; //自动输出MAX_1的类型
#undef MAX_1                //取消MAX_1的定义，#undef可以放在函数内也可在函数外
//std::cout << MAX_1 << '\n';    //这时候再输出便会报错

printf("%lld\n", MAX_2);    //const定义的的常量在定义域内永久有效，且可以展示在参数列表中
printf("%d\n", MAX_2);      //会报警，MAX_2的值超过int的长度，输出的值不正确
std::cout << MAX_2 << '\n'; //自动输出MAX_2的类型

return 0;
}

 
const修饰指针
 const修饰*：指向的对象只读，指针的指向可变——星号表示指向运算符，const将指针指向的地址区域的变量值固定下来
 const修饰 p：指向的对象值可以变，指针的指向不可变（即该指针只会指向一个特定的内存地址，const固定了指针p的值）
 const同时修饰*和p：指向的内容和指针本身都不可以改变

int main()
{
    int a = 1;
    int b = 2;
    int c = 3;
    const int d = 4;

int const *pa = &a;         //pa是一个指针，指向一个int型的"常量"a，等价于const int *pa
int *const pb = &b;         //pb是一个常指针，指向一个int型的变量b
const int *const pc = &c;   //pc是一个常指针，指向一个int型的常量c
//int *const pd = &d;       //非法，不可以用一个指向变量的指针去指向const值（像是程序的自我保护机制）

//*pa = 10;                 //非法，编译器认为，pa指向的量是一个常量，不可以通过指针去改变它
a = 10;                     //合法！定义的a(int)实际上不是一个常量，所以可以直接修改它的值
pa = &d;                    //合法，pa本身并不是常指针，这其实是将一个指向“常量”的指针变量指向了一个真的常量
                            //实际上还是无法修改d(const)的值

*pb = 10;                   //合法，pb指向的变量可以改变
//pb = &c;                  //非法，指针pb为常指针，只能指向固定的地址

//*pc = 10;                 //非法，pc指向的量是一个常量
//pc = &d;                  //非法，指针pc为常指针，只能指向固定的地址
}

                
            

            
                    
                                Tavior
                
                    Section 7：修饰符

C++允许在定义char，int和double类型前面放置修饰符：
signed
unsigned
long
short

以上四种修饰符都可以用于int(没有必要用signed和long修饰int，此外，int还可以使用long long修饰)

signed/unsigned还可以修饰char（用的非常少）

long可以修饰double（但没有任何意义）

注意，不要将有符号和无符号的变量互相赋值，例如
short int a = 50000;
short unsigned int b;
b = a;

此时b并非"50000"，而是"-15536"（unsigned的第一位不是符号）

类型限定符
const：由其修饰的变量在程序执行期间不能被修改
volatile：对一般的变量，编译器会进行优化，将内存中的变量值放在寄存器中加快读写效率；但若修饰volatile，则告诉编译器不优化，程序直接从内存中读取该变量（在多线程编程中会使用，涉及到内存和寄存器等知识，暂时不管）
restrict：出现于C99标准中，C++没有这个指令，虽然编译器保留了对其的支持，这个优化非常底层，目前不用管

下方笔记中提到了一个关键字explicit，他举的例子是面向对象的程序，目前看不懂
                
            

            
                    
                                Tavior
                
                    Section 8：存储类

存储类定义了C++程序中变量和函数的范围以及生命周期。以下是C++中可用的存储类
auto：声明变量时根据初始化表达式自动判断变量类型(C++17起被弃用)
register：定义存储在寄存器而非内存中的局部变量（变量最大尺寸为寄存器的大小，且没有内存地址）(C++17起被弃用)
static：指示编译器自该变量声明时起至程序结束为止，局部变量都保持存在（否则在离开某个函数的时候，函数内部定义的局部变量都会销毁）。static也可以应用于全局变量，使得变量的作用域限制在声明它的.cpp文件内
extern：提供全局变量或函数的引用，全局变量对于所有文件都是可见的，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置

这里举一个例子说明static对全局变量的限制以及extern的引用方法

//文件1: func.cpp
#include <iostream>
extern int count;

void func(void)
{
    static int i = 0;
    i++;
    std::cout << i << "       " << count << std::endl;
    return;
}


//文件2: main.cpp
//static int count = 3;     //编译器报错，static声明的全局变量只能够在当前.cpp文件中调用
                            //无法跨文件调用
int count = 3;              //普通的全局变量是可以在其他文件用extern调用的
void func(void);

int main()
{
    while(count--)
    {
        func();
    }
    return 0;
}

mutable：仅适用于类的对象（面向对象编程时再学习）
thread_local(C++11开始引入)：使用该说明符的变量仅可以在创建它的线程上访问。变量随线程的创建而创建，随线程的销毁而销毁。该说明符可以和static或者extern一同使用。一般用于需要保证线程安全的函数中（常见于面向对象编程，暂时不学习）。

                
            

            
                    
                                Tavior
                
                    Section 9：循环

循环和C语言中的情况基本相同，这里只补充几个之前不知道内容
和while一样，for循环在运行前也会先判断条件
int a = 0;
for(int i=0;i<1;i++)
        a++;
cout << a << endl;     //输出0

for语句中可以用冒号指定遍历数组
#include<iostream>
#include<string>
#include<cctype>
using namespace std;

int main()
{
    int my_array[5] = {1,2,3,4,5};
    string str = "some string";     //声明一个字符串型的变量str，并初始化
                                    //与C风格的字符串不同，string 的结尾没有结束标志'\0'
    for(int x : my_array)           //Cpp特有写法，临时变量x另外开辟内存空间，遍历拷贝my_array中的值
    {
        x *= 2;                     //x对应的内存地址便是my_array中某个元素的内存地址，直接对my_array数组乘2
        cout << x << endl;
    }
    for(int i=0;i<5;i++)
    {
        cout << my_array[i] << endl;    //数组没有改变
    }
    


for(int &x : my_array)          //Cpp特有写法，冒号表示整型变量x的实际地址顺序遍历my_array中的所有元素
{
    x *= 2;                     //x对应的内存地址便是my_array中某个元素的内存地址，直接对my_array数组乘2
    cout << x << endl;
}
for(int i=0;i<5;i++)
{
    cout << my_array[i] << endl;    //数组发生变化
}

for(char &c : str)
{
    c = toupper(c);             //该函数将小写转换为大写
}
cout << str << endl;            //直接输出整个字符串

return 0;
}


do...while循环在循环尾部检查条件，因而会保证至少执行一次
do
{
    statements;
}while(condition);

循环控制语句
break：中止循环或者switch
continue：中止循环的剩余部分，直接测试条件，准备进入下一轮循环或者退出
goto：将控制转移到被标记的语句，容易引起bug，很少使用

                
            

            
                    
                                Tavior
                
                    Section 10：判断

Cpp中的判断语句和C基本相同，只回顾一下之前用的比较少的switch语句和?运算符
switch语句：测试一个变量(expression)等于多个值(case)时的情况：
 switch中的expression必须是整型/枚举类型/class型
 switch中可以包含任意数量的case，case后跟的常量表达式应与expression数据类型相同
条件运算符?：Exp1 ? Exp2 : Exp3若Exp1为真，则计算Exp2的值，并将其作为整个( ? : )表达式的值；若Exp1为假， 则计算Exp3的值，并将其作为整个( ? : )表达式的值（直接写if...else不香吗）
                
            

            
                    
                                Tavior
                
                    Section 11：数字

普通的数字这里不提了，回顾一下伪随机数的知识

C++中自带的随机数生成器涉及的两个函数一个是srand()一个是rand()
void srand(unsigned seed)是使用一个正整形seed作为种子，调用了该函数后才能调用rand()函数获取随机数
种子相同则生成的随机数表相同，为了两次获得不同的随机数，一般都是使用系统时间time(NULL)作为种子
unsigned int rand(void)每次使用返回一个随机正整数，其最大值与操作系统有关
常用取模的方法获取限定范围内的随机数（如果范围太大，比如模10000，这个方法就不太好了，因为windows下产生的RAND_MAX只有32767）
C++的rand()函数生成大量随机数的时候周期行为比较严重，进阶的方法是使用random库中的随机数生成器（这里略去），并且这也是C++11标准推荐的用法——参考<random>，更详细的内容先跳过，等以后要写随机数的时候再说
                
            

            
                    
                                Tavior
                
                    Section 12：数组

所有的数组都是由连续的内存位置组成，最低的地址对应第一个元素，最高的对应最后一个元素

其实“数组”这个名字不太恰当，因为除了数字，任意有效的C++数据类型都可以构成数组，其一般形式是

type arrayname[size]，比如type可以是char, int, double等等.

一些笔记：
array直接初始化char数组需要以一个null终止符\0结尾
char a1[] = {'C', '+', '+'};           //合法，编译器自动添加终止符
char a2[] = {'C', '+', '+', '\0'};     //合法，手动添加终止符
char a3[] = {'C++'};                   //合法，编译器自动动添加终止符
char a4[3] = {'C++'};                  //报错，长度为3的数组没有地方放置终止符

注意，上面的字符数组虽然只有三个直接字符，但是长度为4——3个字符+一个\0，正确的写法是char a4[4] = {'C++'};
但是对于int和double型的数组，最后不需要补\0，也就是说int a5[3] = {0,1,2};的初始化是合法的
只有初始化时可以用聚合的方法（指的是int array[] = {1,2,3};这种写法），定义之后再赋值就不可以了
数组使用时可以是含变量的表达式，但是声明的时候必须是常量表达式——即数组的长度是一个确定的值
array是固定大小的，不能额外增加元素，如果向定义不固定大小的字符，可以使用vector标准库——确切来说是一个类，相当于一个动态数组
数组的长度可以用sizeof读取，之后除掉数组元素类型的长度sizeof(array) / sizeof(array[0])
#include<iostream>
#include<vector>    //包含变长数组所需的类文件vector
using namespace std;
int main()
{
//char数组最后一位要补终止符'\0'
    char a1[] = {'C', '+', '+'};           //合法，编译器自动添加终止符
    char a2[] = {'C', '+', '+', '\0'};     //合法，手动添加终止符
    char a3[] = "C++";                     //合法，编译器自动动添加终止符
    //char a4[3] = {'C++'};                //报错，长度为3的数组没有地方放置终止符

    //但是int, double数组不需要
    int a5[3] = {0,1,2};
    double a6[3] = {0.0,1.0,2.0};

    cout << a3 <<endl;                     //C++中，将char*或者char[]传递给cout会输出整个字符串
    printf("%s\n",a3);                     //同样，输出”C++“

    //若要输出字符串的首字母，可以输出*a3[0]或者a3[0]
    cout << a3[0] <<endl;                  //输出C
    //也可以*(&a3[0])，是标准改了吗
    cout << *(&a3[0]) <<endl;              //输出C

    //只有定义同时初始化数组时才能采取聚合方法定义，赋值时不可以
    //int a7[];                             //非法，a7的内存占据大小未知，无法分配内存
    int a7[3];                              //合法
    //a7[] = {0,1,2};                       //非法，不可以聚合赋值
    for(int i=0; i<3;i++)
    {
        a7[i] = i;                          //合法，逐个赋值
    }

    const int LEN = 3;
    int len = 3;
    int a8[LEN + 1];                        //合法
    //int a8[len];                          //在目前的编译器中合法，但会输出警告
    //int a9[(const int)len];               //在目前的编译器中合法，但会输出警告
                                            //并没有转化成功
    //若一开始没有办法确定数组大小，可以在计算完所需数组长度之后临时定义一个const变量
    //也可以用malloc函数(memory allocate)，先声明再分配内存——这个办法之后会详细学，这里只给个例子
    int *a9;                                //数组都是指针
    a9 = (int *)malloc(len * sizeof(int));  //分配成功，malloc函数返回内存首地址，否则返回NULL

    return 0;
}

在深入学习面向对象编程时，还会接触到容器的概念，到时候再来系统学习构建变长数组的方法——vector类型
多维数组：一般声明为type name[size1][size2]...[sizeN]，特别的对于二维数组，第一位为行，第二位为列。C++中多维数组的元素存储是行优先的，即先存储第一行的数据再存储第二行的数据array[0][0], array[0][1], ..., array[0][n], array[1][0], array[1][1], ...。例如以下两种初始化方法得到的数组相同：

int array[3][4] = 
{
    {0,1,2,3},
    {4,5,6,7},
    {8,9,10,11},
};

int array[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

上述规则可以进一步拓展到多维数组：多维数组存储是角标由左往右优先
指向数组的指针：数组名是指向数组中第一个元素的指针，因而可以用(array + n)这种形式访问第n+1个数组元素，如

int array[3] = {1,2,3};
int *p = NULL;
p = array;

cout << *p << endl;                     //输出1
cout << *(p+1) << endl;                 //输出2
cout << *(p+2) << endl;                 //输出3 
cout << *(p+3) << endl;                 //编译不报错，运行给一个其他值
cout << *(p+100) << endl;               //编译不报错，运行报错
//上面最后两种情况是指针访问超出了数组范围，编译器不会报错，而且可能给出一个值
//实际写代码时一定要谨慎

传递数组给函数
 C++中将数组传给函数，会自动转化为指针类型，实际传的是地址
 有以下三种方式传递(指针，已定义大小和未定义大小的数组)

  void func(int *p)，void func(int array[10])，void func(int array[])

  数组的长度无关紧要，C++不会对形参边界检查

函数返回数组
  C++不允许返回一个完整的数组作为函数的参数，但可以返回一个指向数组的指针，例如int * func()
  C++不支持在函数外返回局部变量的地址（除了static局部变量）——在编译器中似乎不加static也可以返回输出正常的值，runoob下的笔记也是同样的结论，但是为了谨慎起见，还是写上比较好
#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

int * getRandom1(void)
{
    static int array[10];                       //函数只能返回static局域变量的地址
                                                //去掉static工作也正常，但是谨慎起见还是写上吧
    srand((unsigned)time(NULL));
    for(int i = 0; i < 10; i++)
    {
        array[i] = rand();
    } 
    return array;
}

int * getRandom2(int len)
{
    static int * p;                             

    p = (int *)malloc(len * sizeof(int));       //获取了长度之后再分配内存

srand((unsigned)time(NULL));
for(int i = 0; i < len; i++)
{
    *(p + i) = rand();
} 
return p;
}

int main()
{
    int *p;
    p = getRandom1();                //只能获得固定长度的数组（数组长度不可为变量，传参会报错）

for(int i = 0; i < 10; i++)
{
    cout << *(p + i) << endl;
}
cout << endl;

int *random;
int len;
len = 8;

random = getRandom2(len);       //前期程序计算完成之后，根据实际需要开辟长度为变量len的数组
for(int i = 0; i < len; i++)
{
    cout << *(random + i) << endl;
}

return 0;    
}

                
            

            
                    
                                Tavior
                
                    小毛龙 原来是这样ww，我看网上的文档好像都是说刷新缓冲区没必要就不要弄，会拖慢运行（虽然我觉得也慢不了多少 🤣 ）
                
            

            
                    
                                Tavior
                
                    Section 13：字符串

C++提供了两种字符串表示形式
C风格字符串
 本质上是使用null字符\0中止的一维字符数组——编译器会自动将其加在字符串末尾，并且输出时会忽略掉\0
 具体的函数略去，以后碰到再学
 对于string和char类型数组，cout会直接输出内容，其余数组输入变量名则会输出地址
 暂时不考虑输入参数（科学计算，不需要前端和交互 😅 ）
C++的string类类型

#include <iostream>
#include <string>
#include <cstring>
//string类提供了很多关于字符串的操作，如在末尾添加字符、插入字符、
//删除字符、查找子字符串、替换字符串等
using namespace std;

int main()
{
    string str1 = "hello";      //string是<string>库里的一种类型
    string str2 = "world";
    string str3;
    

int len;

str3 = str1;                //复制str1到str3
cout << "str3: " << str3 << endl;

str3 = str1 + str2;         //连接str1和str2
cout << "str3: " << str3 << endl;

str3 = str1 + " " + str2;   //直接用引号包含的字符在字符串“+”运算中自动识别为string型
//str3 = "hello" + "world"; //报错，字符串的字面值并非标准库的string型，不能直接相加
cout << "str3: " << str3 << endl;

len = str1.size();          //新东西，之后学面向对象的时候慢慢学
cout << "str1.size(): " << len << endl;                     //输出11
cout << "sizeof(str1): " << sizeof(str1) << endl;           //输出24 = (5 + 1) * 4
//sizeof是运算符，可以用函数做参数，返回函数返回值的长度（如int函数返回为4）
//sizeof的参数是结构类型或者变量时，其返回实际大小；若是静态空间数组时，其返回全部数组的尺寸
//传入sizeof()的若是指针，则返回指针所占的内存空间
//问题来了，string类型的str1传进去为什么会吐出24？这个类型到底是一堆指针还是什么别的？

cout << "sizeof(\"hello\"): " << sizeof("hello") << endl;   //输出6 = 5 + 1，传入的是字符串数组
cout << "strlen(\"hello\"): " << strlen("hello") << endl;   //输出5

char const* str4 = "hello";                             //不加const编译报警，需要固定这个指针指向一个“常量”
cout << "sizeof(str4): " << sizeof(str4) << endl;       //输出4，传入的是指向字符串数组首位的指针
cout << "strlen(*str4): " << sizeof(*str4) << endl;     //输出1，传入的是第一个char字符
cout << "strlen(str4): " << strlen(str4) << endl;       //输出5，传入的是第一个char字符
//cout << "strlen(*str4): " << strlen(*str4) << endl;   //报错
//cout << "strlen(str1): " << strlen(str1) << endl;     //报错
//strlen是C语言的string库中的函数，因而不能用于C++中的string类型，strlen只能用char*做参数，必须以"\0"结尾

return 0;
}


const char数组，const char*数组以及int数组指针的输出

#include <iostream>
using namespace std;

int main()
{
    const char str1[8] = "abcdefg";
    const char* str2 = "1234567";

cout << str2 << endl;           //输出1234567
cout << *str2 << endl;          //输出1（指针指向第一个字符）
cout << str2 + 1 << endl;       //输出234567（跳过第一个字符）
cout << *(str2 + 1) << endl;    //输出2(第二个字符所在的地址)
cout << (*str2 + 1) << endl;    //输出51(字符转化为ASCII码计算)

cout << "-----------------------" << endl;    //华丽的分割线

const char *charp;    //声明两个字符串“常量”指针
charp = str1;                  //指针指向str1
cout << charp << endl;         //输出abcdefg

charp = &str1[0];              //指针指向str1的第1个元素
cout << charp << endl;         //输出abcdefg（自动往后输出直到遇到终止符）

charp = &str1[1];              //指针指向str1的第2个元素
cout << charp << endl;         //输出bcdefg（自动往后输出直到遇到终止符）

cout << "-----------------------" << endl;    //华丽的分割线

int i[5] = {1,2,3,4,5};
int j = 1;
int *ip;
ip = i;                        //i实际上是数组的指针
//ip = j;                      //报错
cout << i << endl;             //输出数组i的首项地址
cout << *i << endl;            //输出数组i的首项1
cout << ip << endl;             //输出数组i的首项地址
cout << *ip << endl;            //输出数组i的首项1

ip = &j;
cout << ip << endl;            //输出整型j的地址
*ip = j;
cout << ip << endl;            //输出整型j的地址

return 0;
}

                
            

            
                    
                                小毛龙
                
                    更新呢（敲碗
                
            

            
                    
                                Tavior
                
                    小毛龙 改了一星期论文，今天接着更新~
                
            

            
                    
                                Tavior
                
                    Section 14：指针

先上runoob的典中典：《学习C++的指针既简单又有趣》 😅 

指针是一个变量，其值为另一个变量的内存地址，其占用的字节数和编译器有关，32位编译器为4字节，64位为8字节

两个一元运算符：*提取指针变量指向位置的值；&给出变量存储位置的地址
空指针

 声明变量时若不直接赋值指针，一般先把指针指向NULL值：int *ip = NULL;，该值实际上是指向地址为0的内存——一般的操作系统不允许访问该地址，也可以直接用if语句if(ip)判断指针是否为空指针（NULL = 0）

另外C++11后提倡用nullptr替代NULL
指针的算术运算

 指针是用数值表示的地址，因而可以对其进行算术运算（++, --, +, -）——当然，用乘除法会报错

 对指针的算术运算限定于加减整数，其含义是按照指针定义的类型挪动对应字节数（如对char型指针，+1挪动一个字节，对int型指针，+1挪动4个字节）而且编译器并不会检查越界问题，所以这种操作时一定要小心数组越界
指针可以用关系运算符比较，如==, >, <。恒等运算不言而喻；后两者常用于数组中的判定语句，同一个数组中的元素在内存上是连续的，因而内存地址也会从小到大排列——这种比较不适用于char型指针，若需对char型指针进行大小比较，则需要强制转换类型，如下例所示

#include <iostream>

using namespace std;
const int MAX = 3;

int main()
{
    int array[MAX] = {1,2,3};
    int *iptr;

iptr = array;        //iptr被赋值为array数组的首项地址
for(int i = 0; i<3; i++)
{
    cout << "Address of array[" << i << "] = ";
    cout << iptr << endl;
    cout << "Value of array[" << i << "] = ";
    cout << *iptr << endl;                          //间隔为4

    iptr++;
    //array++;                                      //这是非法的
    //指向数组的指针实际是一个常量指针(int *array[]等价于int *const array)，不可以做为左值
}

cout << *(iptr + 10) << endl;                       //系统不会报错，仍然会读取
//*(iptr + 10) = 0;                                 //系统不会报错！这种行为就很危险了

char string[MAX + 1] = "abc";
char *cptr;

cptr = string;        //cptr被赋值为string字符串的首项地址
for(int i = 0; i<3; i++)
{
    cout << "Address of string[" << i << "] = ";
    cout << (int*)cptr << endl;      
    //注意必须用强制类型转换才能提取char型变量的地址
    //否则对于char*型指针，系统会自动输出字符串值直到遇到终止符\0为止
    //&cptr提取的是指针变量cptr的地址，而非cptr指向变量的地址
    cout << "Value of string[" << i << "] = ";      //间隔为1
    cout << *cptr << endl;

    cptr++;
}

while((int*)cptr > (int *)string)                   //内存地址比较也不适用于char型数组，需强制转换
{
    cptr--;
    cout << "Address of character " << *cptr << " = ";
    cout << (int*)cptr << endl;      
    //注意必须用强制类型转换才能提取char型变量的地址
    //否则对于char*型指针，系统会自动输出字符串值直到遇到终止符\0为止
    //&cptr提取的是指针变量cptr的地址，而非cptr指向变量的地址
}

//取地址符&与数组
cout << "array      " << array      << endl
     << "&array[0]  " << &array     << endl
     << "&array     " << &array     << endl         //以上三条输出结果相同，都是array的首地址
     << "array + 1  " << array + 1  << endl         //输出array[1]的地址
     << "&array + 1 " << &array + 1 << endl         //将array这个长为3的数组看成整体，向后挪动一个数组长度的内存
     << "array + 3  " << array + 3  << endl;        //内存向后挪动3个整型（一个数组长度），与前一条输出一样

cout << "string      " << string      << endl       //输出abc
     << "&string[0]  " << &string     << endl       //string的首地址
     << "&string     " << &string     << endl       //string的首地址
     << "string + 1  " << string + 1  << endl       //输出bc
     << "&string + 1 " << &string + 1 << endl       //将string这个长为3+1的字符串看成整体，向后挪动一个数组长度的内存
     << "string + 3  " << (int *)(string + 4)  << endl;      //内存向后挪动4个字符长度（一个数组长度），与前一条输出一样
return 0;
}


指针数组——指针的指针

 有时候，我们需要让数组存储指向int或者char或者其他类型数据的指针，则可以分配一个指针数组，如

 int *pptr[MAX]，声明了一个长度为MAX，数据类型为整型指针的数组pptr，实例如下

#include<iostream>
using namespace std;
const int MAX = 3;

int main()
{
    int array[MAX] = {1,2,3};
    int *pptr[MAX];

for(int i=0;i<3;++i)
{
    pptr[i] = &array[i];    //pptr为一个整形指针数组，储存array三个分量的内存地址
    cout << "Value of array[" << i << "] = ";
    cout << *pptr[i] << endl;                      
}

cout << "---------------------" << endl;    //华丽的分割线

//也可以用指向字符的指针数组存储字符串列表，如
char const *names[MAX] = {
    "Alice",
    "Bob",
    "Cindy",
};                          //不可以通过指针修改names列表中的值，即该数组指针指向固定的地址
//不加const会报警

for(int i=0;i<3;++i)
{
    pptr[i] = &array[i];    //pptr为一个整形指针数组，储存array三个分量的内存地址
    cout << "---------------------" << endl;    //华丽的分割线
    cout << "Value of names[" << i << "] = ";
    cout << names[i] << endl;               //这里不加*，这和char型数组读取规则有关
    cout << *names[i] << endl;            //输出A,B,C                   
    cout << &names[i] << endl;            //输出names三个分量的地址（32位系统下相距4个字节）
    cout << (int*)names[i] << endl;       
    //输出names三个分量的地址（相距5+1和3+1个字节，对应names存储的三个字符串加终止符的长度）
}
}


注意，C++与C的运算优先级不一样，C++中 * 的运算优先级低于[]，因而* ptr[]是ptr先和[]结合为数组，再和*结合形成数组的元素类型是int *类型，该数组中的元素是指向int型的指针，称为指针数组
而int (*ptr)[]中，()和[]的优先级一样，从左至右先计算*ptr，ptr为一个指针，指向一个数组，称为数组指针，这个用法之前没怎么接触过，下面给一个例子（里面关于数组指针的存取位置有点绕）

#include<iostream>
using namespace std;

int main()
{
    int matrix[3][2] = {
        {1,2},
        {3,4},
        {5,6}
    };

//注意！多维数组matrix实际上是一个三维整形指针数组，分别指向三个长度为2的整型数组

int (*ptr)[2] = matrix;     //定义了数组指针ptr指向3*2的二维数组
//(*ptr)数组指针后跟的是[2]的含义是该数组指针指向的数组中的每一个元素都是一个指向长度为2的整形数组的指针

for(int i=0; i<3; ++i)
{
    cout << "---------------------" << endl;    //华丽的分割线
    cout << ptr + i << endl;
    cout << &matrix[i] << endl;     //这两条输出将matrix视为一维数组时第i个元素的地址

    cout << **(ptr + i) << endl;    
    //ptr = matrix，按matrix的元素（3个二维数组）挪动，因而实际上是输出第i+1行的第一项
    cout << matrix[i][0] << endl;   //这两个输出的结果是一样的，都是输出1,3,5
}

for(int j=0; j<3; ++j)
{
    cout << "---------------------" << endl;    //华丽的分割线
    cout << *(*(ptr + j) + 1) << endl;          //先挪到matrix的第j+1行，取值后得到的是第j+1个二维数组，然后再移动1个
    cout << matrix[j][1] << endl;               //和上一条输出一样，都是2,4,6
}

return 0;
}


C++支持传入指针给函数，也支持从函数返回指针，只是需要声明的时候加上 * 号，另外为了稳妥起见，在返回函数内的局域变量地址给外部函数的时候最好在定义时加上static
有三种形式的传递：
 值传递：先将变量拷贝到另一个位置，作为形参传入函数，函数结束后销毁，不影响原来变量的值
 指针传递：直接传递指向实参的指针（地址），函数直接对原来的变量进行修改
 引用传递：传入的形参实际上是实参地址的拷贝，被调用函数对形参的任何操作都被处理成间接寻址——通过栈中存放的地址访问主调函数中的实参变量，因而也会改变原变量的值。

#include<iostream>
using namespace std;

void by_value(int n)
{
    cout<< "值传递——函数操作地址：" << &n << endl;      //返回地址与实参不一样
    n++;
    return;
}
void by_pointer(int *n)
{
    cout<< "指针传递——函数操作地址：" << n << endl;     //返回地址与实参一样
    *n = *n + 1;
    return;
}
void by_reference(int &n)
{
    cout<< "引用传递——函数操作地址：" << &n << endl;    //返回地址与实参一样
    n++;
    return;
}

int main()
{
    int n = 1;
    cout<< "实参地址：" << &n << endl;
    by_value(n);
    cout<< "值传递后的实参值：" << n << endl;           //输出1

by_pointer(&n);
cout<< "指针传递后的实参值：" << n << endl;         //输出2

by_reference(n);                                    //注意这里直接传入变量即可
cout<< "引用传递后的实参值：" << n << endl;         //输出3

return 0;
}


引用传参和指针传参的区别：
 引用必须引用对象，由于引用不能为NULL，因此更安全
 指针是保存内存地址的变量。引用与其引用的项具有相同的内存地址。
 指针可以迭代数组，比如传递数组变量时实际上是传递数组首位的地址指针，也因此，传递指针可能会导致越界访问
 尽可能使用引用，必要时使用指针。但是，如果想编写同时使用C和C++编译器编译的C代码，则必须使用指针
                
            

            
                    
                                Tavior
                
                    Section 15：引用

引用变量& r是已有变量的“别名”——即某个已存在变量的另一个名字。这里的&读作引用。

引用与指针的区别
有空指针，但没有空引用，引用必须连接到一块合法的内存
一旦引用被初始化为一个对象，就不能指向另一个对象。指针可以在任何时候指向其他对象
引用必须在创建的同时初始化，指针可以在任何时候初始化

故而引用更像是一个const指针，但是引用变量没有自己的地址，若初始化int &r = i;则&r == &i是同一个地址，因而说引用是变量的一个“别名”。

引用常用于函数参数列表和函数返回值，具体见下面的例子

使用引用来替代返回指针据说会更容易维护。返回引用等价于返回一个指向返回值的隐式指针，这样做可以让函数放在赋值语句左值的位置

#include<iostream>
using namespace std;

void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
    

return;
}

double vals[]={1.1,2.2,3.3,4.4,5.5};

double& setValues(int i)
{
    double& ref = vals[i];     //vals是上面定义的全局变量
    return ref;                //返回全局数组中第i个元素的引用

//double q = 2.2;          
//return q;                //这样设置是非法的，虽然编译通过，但是调试时会显示segment fault
}

int main()
{
    int i, j;
    int &r = i;                                 //这里的&读作引用，必须初始化        

    //&r = j;                                   //报错，引用一经定义无法修改
    int *const iptr = &i;                       //常指针也需要定义同时初始化

i = 1;
j = 1;

cout << "Value of i:     " << i     << endl;
cout << "Value of r:     " << r     << endl;
cout << "Value of *iptr: " << *iptr << endl;
cout << "Address of i:   " << &i    << endl;
cout << "Address of r:   " << &r    << endl;     //这里的&表示取地址
cout << "Address of iptr:" << &iptr << endl;     //与上面两个地址不同，常指针有自己的内存位置
//可以看出r确实是i的一个“别名”

cout << "------------------------"  << endl;     //华丽的分割线

r = 2;
cout << "Value of i:     " << i     << endl;
cout << "Value of r:     " << r     << endl;
cout << "Value of *iptr: " << *iptr << endl;    
//所有值都会一起改变，全部输出2

cout << "------------------------"  << endl;     //华丽的分割线
cout << "Value of i:     " << i     << endl;     //2
cout << "Value of j:     " << j     << endl;     //1
swap(i,j);                                       
cout << "Value of i:     " << i     << endl;     //1
cout << "Value of j:     " << j     << endl;     //2

const int k = 3;
//注意，引用传入的参数只能传入变量，不能传入常值
//swap(1,2);                                     //会报错
//swap(k,j);                                     //会报错，但报错的原因是const int和int不匹配

cout << "------------------------"  << endl;     //华丽的分割线
cout << "Value of val[2]:" <<vals[2]<< endl;     //2.2
setValues(2) = 7.7;                              //setValues函数返回的是一个引用，指向的是vals[2]
cout << "Value of val[2]:" <<vals[2]<< endl;     //7.7，通过此法直接修改了全局变量中的值

//setValues(8) = 7.7;                            //编译器不会报错，但是ref的值变成了-nan(0xffffd00000002)

return 0;
}



    
            下一页 »