C++自学笔记 非零基础（01）

1.输出HelloWorld

#include "iostream"
using namespace std;
int main(){
    cout<<"你好，世界!Hello,World!"<<endl;
    return 0;
}
1
2
3
4
5
6

2.常量认识 const #define

//常量的定义方式
/**
 * #define 宏常量
 * const 修饰的变量
 * @return
 */

#define Day 7

int main() {
    cout << "Aaa" << endl;
    //Day=7;  //常量一修改 报错
    cout << "一周一共有:" << Day << "天.";

    //const修饰的变量
    const int month = 12;
    //month =13; //const修改的变量 也称作 常量
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

4.数据类型

/*
 * 数据类型
 * 数据类型存在意义：给变量分配一个合适的空间
 * 整型：
 * short 两个字节   -32767 到 -32767
 * int  4个字节
 * long 32位系统4个字节 64位系统8个字节
 * long long 8个字节
 *
 * 浮点型:
 * 单精度 float  4个字节
 * 双精度 double   8个字节
 *
 * 字符型  1个字节
 * 作用：字符型变量用于显示单个字符
 * 语法 char ch='a';
 *
 * 转义字符 \n 换行 \t 水平制表符 \\ 反斜杠
 *
 * 字符串型
 * char 变量名[] ="字符串值";  //c风格
 * string 变量名="字符串值";  需要添加头 #include<string>
 *
 * bool布尔类型 bool
 *      false 假         true 真
 *      本质 1代表真 0代表假
; */

int main() {
    //整型
    short num1 = 10;
    int nu2 = 10;
    long num3 = 10;
    long long num4 = 10;

    //双精度
    float f1 = 3.14f;
    double d1 = 3.14;

    //字符型变量
    char ch = 'a';

    //bool 数据类型
    bool flag = true;
    bool flag2 = false;


    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

5.数据输入（cin）

int main() {

    //整型
    int a = 0;
    cout << "请对a进行赋值" << endl;
    cin >> a;
    cout << "a=" << a << endl;


    return 0;
}
1
2
3
4
5
6
7
8
9
10
11

6.运算符

int main() {
    //1.算术运算符
    //加减乘除
    int a = 10;
    int b = 3;
    cout << "a-b=" << a - b << endl;
    cout << "a+b=" << a + b << endl;
    cout << "a/b=" << a / b << endl; //整除        整数/整数 = 整数
    cout << "sizeof(a/b)=" << sizeof(4.0 / 2.0) << endl; //整除
    cout << "sizeof(a/b)=" << sizeof(4 / 2) << endl; //整除
    cout << "a%b=" << a % b << endl; //取余

    //赋值运算符     与java相同
    // = += -= &= /= %=
    int aa = 0;
    aa += aa;

    //比较运算符     与java相同
    //   ==    !=     <   >     <=    >=

    //逻辑运算符     与java相同
    // !   &&  ||  优先级  ! > && > ||
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

7.程序流程

if else; while; do while; for

int main() {
    //选择结构 if else  与java相同 有嵌套和多个else if
    if (true) {
        cout << "是" << endl;
    } else {
        cout << "否" << endl;
    }

    //三目运算符 与java相同
    int a = 10;
    int b = 20;
    a > b ? a : b;
    cout << "a与b谁大？" << (a > b ? "a大" : "b大") << endl;

    //switch 语句 (整型 字符型 枚举类型)
    //switch case break defalut 四个关键词
    switch (10) {
        case 0:
            cout << 0 << endl;
            break;
        case 10:
            cout << 10 << endl;
            break;
        default:
            cout << "default" << endl;
    }

    //while 循环语句 与java一样
    //    break 也可以退出

    //do while 语句 与java一样
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

8. 水仙花数联系

int main() {
    /*
     * 思路
     * 1.循环所有三位数
     * 2.将每一个三位数每个位分开 ，求3次幂，并判断是否等于该值本身
     */
//    int a=111;
//    int b=a%10;
//    int c=(a/10)%10;
//    int d=(c/100)%10;

    int start = 100;
    int end = 999;
    int num = 0;
    while (start <= end) {
        int b = start % 10;
        int c = (start / 10) % 10;
        int d = (start / 100) % 10;
        if (b * b * b + c * c * c + d * d * d == start) {
            num = num + 1;
            cout << "第" << num << "个" << "水仙花数=" << start << endl;
        }
        start = start + 1;
    }

    cout << "升级版水仙花数" << endl;
    start = 1000;
    end = 9999;
    num = 0;
    while (start <= end) {
        int b = start % 10;
        int c = (start / 10) % 10;
        int d = (start / 100) % 10;
        int e = (start / 1000) % 10;
        if (b * b * b * b + c * c * c * c + d * d * d * d + e * e * e * e == start) {
            num = num + 1;
            cout << "第" << num << "个" << "水仙花数=" << start << endl;
        }
        start = start + 1;
    }
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

9.for循环

/**
 * for循环
 * 作用：满足循环条件，执行循环语句
 * 语法：for(其实表达式;条件表达式;末尾循环体){循环语句}
 * @return
 */
int main() {
    //for循环
    //从数字 0 打印到 9
    for(int i=0;i<=9;i++){
        cout<<i<<endl;
    }

    //输出1到100 这些数字
    //从100个数字中 找到包含7和，7的倍数，改为敲桌子
    for(int i=0;i<=100;i++){
        if(i%7==0){
            cout<<"敲桌子:"<<i<<endl;
        }
        if(i%10==7){
            cout<<"敲桌子:"<<i<<endl;
        }
        if((i/10)%10==7){
            cout<<"敲桌子:"<<i<<endl;
        }
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

10.break continue goto语句

/*
 * break 语句
 * 作用：用于跳出选择结构或者循环结构
 * break使用的时机
 *      出现在switch条件语句中，作用是终止case并跳出switch
 *      出现在循环语句中，作用是跳出当前的循环语句
 *      出现在嵌套循环中，跳出最近的内层循环语句
 *
 * continue
 * 作用：在循环语句中，跳过本次循环中余下尚未执行的语句，继续执行下一次循环
 *
 * goto语句
 * 作用：可以无条件跳转
 * 建议：不推荐使用
 */
int main() {
    //break
    //  1.出现在switch语句中 与java相同
    //  2.出现在循环嵌套语句中 与java相同
    //  3.出现在嵌套循环中  与java相同

    //continue 与java相同
    //只打印奇数
    for(int i=0;i<100;i++){
        if(i%2==0){
            continue;
        }
        cout<<i<<" ";
    }
    cout<<endl;
    
    //goto
    //可利用 goto 构建循环语句，
    //打死都不可用
    cout<<"goto语句学习"<<endl;
    cout<<"1.XXXXXX"<<endl;
    goto FLAG;
    cout<<"2.XXXXXX"<<endl;
    cout<<"3.XXXXXX"<<endl;
    FLAG:
    cout<<"4.XXXXXX"<<endl;
    cout<<"5.XXXXXX"<<endl;
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

11. 数组

/**
 * 数组
 * 所谓数组，就是一个集合，里面存放了相同类型的数据元素
 * 特点1：数组中的每个数据元素都是相同的数据类型
 * 特典2：数组是由连续的内存位置组成的
 *
 * 一维数组定义方式
 * 1. 数据类型 数组名[数组长度];
 * 2. 数组类型 数组名[数组长度] = {值1,值2,值3...}
 * 3. 数据类型 数组名[]={值1,值2,值3...};
 *
 * 一维数组名称用途：
 * 1.可以统计整个数组在内存中的长度
 * 2.可以获取数组在内存中的首地址
 * 注意：数组名是常量，不能进行赋值操作
 *
 * 二维数组定义方式
 * 1.数据类型 数组名[行数][列数];
 * 2.数据类型 数组名[行数][列数]={{数据1,数据2},{数据3,数据4}};
 * 3.数据类型 数组名[行数][列数]={数据1,数据2,数据3,数据4};
 * 4.数据类型 数组名[] [列数] = {数据1,数据2,数据3,s数据4};
 *
 * 二维数组数组名
 * 1.查看二维数组所占内存空间
 * 2.获取二维数组首地址
 * @return
 */
int main() {

    cout<<"一维数组定义方式"<<endl;
    //1. 数据类型 数组名[数组长度];
    // 数组元素坐标从 0 开始。
    int arr[5];
    arr[0]=123;
    cout<<arr[0]<<endl;

    //2. 数组类型 数组名[数组长度] = {值1,值2,值3...}
    int aar2[5]={1,2,3,4,5};
    //打印出的是地址
    cout<<aar2<<endl;

    //3. 数据类型 数组名[]={值1,值2,值3...};
    int aar3[]={1,2,3,4,5};
    cout<<aar3<<endl;

    cout<<endl;
    //1.一维数组名称用途
    cout<<"一维数组名称用途:"<<endl;
    cout<<"aar3 数组长度为"<<sizeof (aar3)<<endl;
    cout<<"aar3 的首地址为:"<<aar3<<endl;
    cout<<"aar3 中每个元素占用内存空间为:"<<sizeof (aar3[0])<<endl;
    cout<<"aar3 中元素个数为:"<<sizeof (aar3)/sizeof (aar3[0])<<endl;
    cout<<"aar3 第二个元素的地址为:"<<&aar3[1]<<endl;

    cout<<endl;
    cout<<"练习题: 找出五只小猪中，最重的小猪"<<endl;
    int xiaoZhuArray[]={300,350,200,150,100};
    int minXiaoZhu=-1;
    for(int i=0;i< size(xiaoZhuArray);i++){
        if(minXiaoZhu<xiaoZhuArray[i]){
            minXiaoZhu=xiaoZhuArray[i];
        }
    }
    cout<<"最重的小猪为:"<<minXiaoZhu<<endl;

    cout<<endl;
    cout<<"冒泡排序"<<endl;
    int arr4[]={4,2,8,0,5,7,1,3,9};
    for(int i=0;i< size(arr4)-1;i++){
        for(int j=0;j< size(arr4)-i-1;j++){
            if(arr4[j]>arr4[j+1]){
                int temp=arr4[j];
                arr4[j]=arr4[j+1];
                arr4[j+1]=temp;
            }
        }
    }
    for(int i=0;i< size(arr4);i++){
        cout<<arr4[i]<<" ";
    }
    cout<<endl;

    cout<<endl;
    cout<<"二维数据"<<endl;
    int arr23[2][3];
    arr23[0][0]=1;
    arr23[0][1]=2;
    arr23[0][2]=3;
    arr23[1][0]=4;
    arr23[1][1]=5;
    arr23[1][2]=6;
    //外层循环打印函数，内层循环打印列数
    for(int i=0;i<2;i++){
        for(int j=0;j<3;j++){
            cout<<arr23[i][j]<<" ";
        }
    }
    cout<<endl;
    // 2.数据类型 数组名[行数][列数]={{数据1,数据2},{数据3,数据4}};
    int arr232[2][3]={{1,2,3},{4,5,6}};

    //3.数据类型 数组名[行数][列数]={数据1,数据2,数据3,数据4};
    int arr233[2][3]={1,2,3,4,5,6};

    //4.数据类型 数组名[] [列数] = {数据1,数据2,数据3,s数据4};
    int arr234[][3]={1,2,3,4,5,6};

    //二维数组 查看内存空间大小
    cout<<"二维数组所占用的空间为:"<<sizeof(arr234)<<endl;
    cout<<"二维数组的首地址为:"<<arr234<<endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

12. 函数

头文件
注意：需要导入# include “iostream” using namespace std;

# include "iostream"
using namespace std;
#ifndef _001HELLOWORLD__012HANSHU_H
#define _001HELLOWORLD__012HANSHU_H

#endif //_001HELLOWORLD__012HANSHU_H

void swap(int,int);

1
2
3
4
5
6
7
8
9

源文件

#include "_012HanShu.h"
# include "iostream"
using namespace std;
/**
 * 函数
 *
 * 作用：将一段经常使用的代码封装起来，减少重复的代码
 *
 * 函数的定义：
 *      1.返回值类型
 *      2.函数名
 *      3.参数列表
 *      4.函数体语句
 *      5.return表达式
 *
 * 语法:
 *      返回值类型 函数名(参数列表){
 *          函数体语句;
 *          return表达式;
 *      }
 *
 * 值传递
 *      函数的形参发生改变，并不会影响实参
 *
 * 函数常见4种样式
 *      1.无参无返
 *      2.有参无返
 *      3.无参有返
 *      4.有参有返
 *
 * 函数声明
 * 作用：告诉编译器函数名称及如何调用函数。函数的实际主体可以单独定义
 * 注意：函数的声明可以多次，但是函数的定义只能有一次
 *
 * 函数的分文件编写
 *      1.创建后缀名为 .h 的头文件
 *      2.创建后缀名为 .cpp 的源文件
 *      3.在头文件中写函数的声明
 *      4.在源文件中写函数的定义
 *      5.在源文件中引用头文件  [#include "_012HanShu.h"]
 * @return
 */
 //可声明多次
int add(int a,int b);
int add(int a,int b);

int main() {
    int returnData=add(3,4);
    cout<<"返回值结果为:"<<returnData<<endl;
    cout<<endl;

    cout<<"值传递"<<endl;
    int num1=100;
    int num2=200;
    cout<<"交换前:"<<"num1="<<num1<<"; num2="<<num2<<endl;
    swap(num1,num2);
    cout<<"交换后:"<<"num1="<<num1<<"; num2="<<num2<<endl;
    cout<<endl;
    
    return 0;
}

/**
 * 实现一个加法函数
 * 功能：传入两个整型数据，计算数据相加额结果，并返回
 */
 int add(int a,int b){
    return a+b;
 }

 void swap(int num1,int num2){
    int temp=num1;
    num1=num2;
    num2=temp;
    cout<<"swap函数中"<<"num1="<<num1<<"; num2="<<num2<<endl;
     return;
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

13.指针

/*
 * 指针
 * 指针的作用：可以通过指针间接访问内存
 *
 * 指针变量的定义和使用
 * 语法：数据类型 * 指针变量;
 *
 * 指针所占的内存空间
 * 32位操作系统 4个字节; 64位操作系统 8个字节;
 *
 * 空指针
 * 空指针：指针变量指向内存中编号为0的空间
 * 用途：初始化指针变量
 * 注意：空指针指向的内存是不可以访问的
 *
 * 野指针
 * 野指针：指针变量指向非法的内存空间
 *
 * const修饰指针
 *      1.const修饰指针 --常量指针
 *          特点:指针的指向可以修改，但是指针指向的值不可以修改
 *      2.const修饰常量 --指针常量
 *      3.const既修饰指针，又修饰常量
 *
 * 指针和数组
 * 利用指针来访问数组中的元素
 *
 * 指针和函数
 * 作用：利用指针作为函数参数，可以修改实参的值
 *
 */
void swap(int *,int * );
int main() {

    //1.定义指针
    int a=10;
    int * p=&a;
    //让指针记录变量a的地址
    p=&a;
    cout<<"a的地址为:"<<&a<<endl;
    cout<<"指针p为:"<<p<<endl;

    //2.使用指针
    //可以通过解引用的方式来找到指针指向的内存
    //指针前加*代表解引用，找到指针指向的内存中的数据
    *p=1000;
    cout<<"a的地址为:"<<a<<endl;
    cout<<"指针p为:"<<*p<<endl;
    cout<<endl;

    cout<<"指针占用空间"<<endl;
    cout<<"指针所占字节数为:"<<sizeof (p)<<endl;
    cout<<endl;

    cout<<"空指针"<<endl;
    //p1的指针地址为0
    int *p1=NULL;
    cout<<"p1指针的地址为:"<<p1<<endl;
    cout<<endl;

    cout<<"野指针"<<endl;
    int *p2=(int*)0x1100;
    cout<<"p2指针的地址为:"<<p2<<endl;
//    cout<<"*p2指针的数据为:"<<*p2<<endl; //报bug
    cout<<endl;

    cout<<"const指针"<<endl;
    //1.常量指针 指针指向的值不可以修改；但是指针的指向可以修改
    const int *p3=&a;
    //*p3 =20;

    //2.指针常量
    //指针的指向不可以更改；但是指针的值可以修改
    int aa=10;
    int * const paa =&aa;

    //3.const既修饰指针，又修饰常量
    //指针的指向和指针的值都不可以修改。
    const int * const paaa=&aa;
    cout<<endl;

    //指针与数组
    cout<<"指针与数组"<<endl;
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    int * arrp=arr; //首地址给arrp
    cout<<"    "<<"第一个元素为"<<*arrp<<endl;
    cout<<"    "<<"第二个元素为"<<*(arrp+1)<<endl;
    cout<<"    "<<"第三个元素为"<<*(arrp+2)<<endl;
    cout<<"指针遍历数组"<<endl;
    for(int i=0;i< size(arr);i++,arrp++){
        cout<<"    "<<"第"<<i<<"个元素值为:"<<*arrp<<endl;
    }
    cout<<endl;

    cout<<"指针和函数"<<endl;
    int num1=1;
    int num2=2;
    cout<<"交换值前:num1="<<num1<<"; num2="<<num2<<endl;
    swap(&num1,&num2);
    cout<<"交换值后:num1="<<num1<<"; num2="<<num2<<endl;
    return 0;
}

//地址传递
void swap(int * num1,int * num2){
    int temp=*num1;
    *num1=*num2;
    *num2=temp;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

14.结构体

/*
 * 结构体
 * 结构体属于用户自定义的数据类型，允许用户存储不同的数据类型
 *
 * 语法：struct 结构体名 {结构体成员列表};
 *      struct 结构体名 变量名
 *      struct 结构体名 变量名 ={成员值，成员2值...}
 *      定义结构体时顺便创建变量  [不建议用]
 *
 * struct 创建的时候，可以省略
 *
 * 结构体数组
 * 作用：将自定义的结构体放入到数组中方便维护
 * 语法：struct 结构体名 数组名[元素个数]={{},{},{},{}};
 *
 * 结构体指针
 * 作用：通过指针访问结构体中的成员
 * 利用操作符 -> 可以通过结构体指针访问结构体属性
 *
 * 结构体嵌套结构体
 *
 * 结构体左函数参数
 * 作用：将结构体作为参数向函数中传递
 * 传递方式有两种：
 *      1.值传递
 *      2.地址传递
 *
 * 结构体中const使用场景
 * 作用：用const来防止误操作
 */

//1.创建学生数据类型：学生包括（姓名，年龄，分数）
struct Student{
    string name;
    int age;
    int score; //分数
} s3;//定义结构体时顺便创建变量

//结构体嵌套结构体
struct Teacher {
    string name;
    string age;
    struct Student s1;
    Student s2;
};

void zhiChuanDi(Student);
void diZhiChuanDi(Student * );
void myPrintf(string,Student);
void myPrintf2(string info,const Student * ps);
int main() {
    //2.通过学生类型创建具体学生
    //2.1  struct 结构体名 变量名
    struct Student s1;
    s1.name="李四";
    s1.age=18;
    s1.score=99;
    //2.2 struct 结构体名 变量名 ={成员值，成员2值...}
    struct Student s2={"张三",20,20};

    cout<<"s1.name="<<s1.name<<"; s1.age="<<s1.age<<"; s1.scroe="<<s1.score<<";"<<endl;
    s3.name="王五";
    s3.age=23;
    s3.score=50;
    cout<<"s3.name="<<s3.name<<"; s3.age="<<s3.age<<"; s3.scroe="<<s3.score<<";"<<endl;

    //struct 创建结构体的时候，可以省略
    Student s4;
    cout<<endl;

    cout<<"结构体数组"<<endl;
    struct Student studentArray1[3];
    studentArray1[0].name="张三";
    studentArray1[0].age=18;
    studentArray1[0].score=100;
    studentArray1[1]={"李四",20,98};

    //定义结构体数组时，赋值
    struct Student studentArray2[2]={{"QQ",19,20},{"WW",20,90}};
    cout<<endl;

    cout<<"结构体指针"<<endl;
    Student s5;
    Student * ps5;
    ps5=&s5;
    ps5->name="minyeling";
    //通过结构体指针，访问结构体的属性
    cout<<"ps5->name="<<ps5->name<<endl;
    cout<<endl;

    cout<<"结构体嵌套结构体"<<endl;
    Teacher t;
    t.name="张老师";
    t.age=50;
    t.s1.name="张三";
    t.s1.age=17;
    t.s1.score=68;
    t.s2={"李四",21,99};
    cout<<endl;

    cout<<"结构体做函数参数传递"<<endl;
    Student s6={"王异",20,30};
    zhiChuanDi(s6);
    myPrintf("值传递后 main函数中： ",s6);
    //地址传递
    diZhiChuanDi(&s6);
    myPrintf("地址传递后 main函数： ",s6);
    cout<<endl;

    cout<<"const修饰的结构体"<<endl;
    Student s7={"吕蒙",25,66};
    myPrintf2("const修饰的结构体:",&s7);
    Student s8={"马超",43,65};

    myPrintf2("const修饰的结构体:",&s8);
    return 0;
}

//结构体值传递
void zhiChuanDi(Student s){
    s.name="刘备";
    myPrintf("值传递函数中： ",s);
}

//结构体地址传递
void diZhiChuanDi(Student * ps){
    ps->name="张飞";
    myPrintf("结构体地址传递函数中 ",*ps);
}

//const 修饰地址传递
void myPrintf2(string info,const  Student * ps){
    //ps->name="小马超";//加入const之后，一旦有修改就会报错，可以防止我们误操作
    cout<<info<<" ps->name="<<ps->name<<"; ps->age"<<ps->age<<"; ps->score"<<ps->score<<";"<<endl;
}

void myPrintf(string info,Student s){
    cout<<info<<" s.name="<<s.name<<"; s.age"<<s.age<<"; s.score"<<s.score<<";"<<endl;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

15