20160203.CCPP体系详解(0013天)
Posted 尹成
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了20160203.CCPP体系详解(0013天)相关的知识，希望对你有一定的参考价值。
程序片段(01):数组.c+02.数组初始化语法.c
内容概要:数组
///01.数组.c
#include <stdio.h>
#include <stdlib.h>
//01.采用容器结构存储数据的要点:
// 1.必须为每个数据分配独立的存储空间
// 2.必须为每个数据分配独立的标识符(变量名称)
//02.C语言之C99语法的特点:
// 针对于VC编译器:
// 1.VC编译器分配数组的时候必须静态分配
// 静态分配:在编译时期确定数组所占据的内存尺寸(字节数)大小
// 2.数组长度必须为真常量(或常量表达式)
// 明确的数组元素个数
// 针对于GCC编译器:
// 1.GCC编译器分配数组的时候采用动态分配
// 动态分配:在执行时期确定数组所占据的内存尺寸
// 2.数组长度可以为伪常量(或变量)
// 不确定的数组元素个数(程序执行时期知道)
//03.伪常量的声明方式:
// 在原始变量的前面添加一个伪常量标识前缀("const")
//04.关于常量的透彻分析:
// 伪常量:const int num = 1;
// 1.具备内存实体:
// 不允许直接进行修改,但允许间接进行修改
// 2.静态分配:
// 在编译时期确定伪常量的值
// 真常量:#define NUM 1
// 1.不具备内存实体:
// 既不允许直接修改,也不允许间接修改
// 2.预编译决定:
// 在预编译时期就已经决定了将宏名为了常量(整型,实型,字符型,字符串型)
int main01(void)
const int num = 10;//常量表达式但是该常量表达式的常量值可以经过间接改变,所以是伪常量-->有内存实体
#define NUM 1//真常量一旦确定了真常量的值,就不允许修改真常量的数据-->无内存实体
//int a[num];//编译的时候确定大小,静态分配,VC不支持
int a[NUM];
//VC必须静态分配,GCC可以动态分配
system("pause");
//05.关于数组使用的要点总结:
// 1.静态数组分配方式:
// (1).int a[5] = 1, 2, 3, 4, 5;//数组元素的类型:int;数组整体的名称:a;数组元素的个数:5;
// 数组元素的具体数据:1, 2, 3, 4, 5
// (2),静态分配:在编译时期就已经确定了数组所占用的内存地址以及内存尺寸(首地址+尺寸)
// 2.分配方式组成分析:
// (1).int:表明数组当中所存储的每个元素的类型
// (2).a:表示数组整体的名称(数组名)
// 数组名的本质是一个常量指针(伪常量)
// (3).:代码块儿分配方式,只能用于声明数组的同时进行使用(既可以局部初始化也可以全部初始化)
// 3.sizeof:
// (1).是一个关键字,而不是一个函数
// (2).如果传递的是数组名,那么求取的内存尺寸是数组整体所占用的内存尺寸(区分数组整体和数组元素)
// 4.%p和%d的使用意义:
// (1).所以数据在内存当中的存储实质都一样,都是二进制数据
// (2).格式控制符只是决定了不同的解析方式:
// %d:内存数据按照有符号十进制(signed int)类型进行解析
// %p:内存数据按照指针意义进行解析
// 5.数组元素以及数组元素的地址:
// a[i]:a[i]表示数组元素的名称,直接写数组元素的名称,相当于访问该数组元素本身(数据)
// 好比叫一个人的名字,目的就是为了这个人知道
// &a[i]:&表示根据变量的名称(内存实体)获取该变量的地址
// 变量的名称:其实就是内存实体的别名(区分:(变量:内存实体)-->(变量名称:变量别名))
// 统称:变量(统一)-->具称:变量别名(唯一)
// 说明:中括号"[]"的优先级高于取内存实体地址符"&"的优先级
int main02(void)
//0,1,2,3,4
int a[5] = 1,2,3,4,5 ;//a:数组名称,a代表该数组的内存首地址
printf("%d \\n", sizeof(a));//sizeof(a):用于获取数组所占用的真实内存尺寸(字节大小)
printf("%p \\n", a);//数组的内存首地址
for (int i = 0; i < 5; i++)
printf("%d, %p \\n", a[i], &a[i]);//i:索引;&:符号表示获取变量的内存首地址
system("pause");
//06.数组元素本身(内存实体)和数组元素地址(内存实体地址)
// 1.数组元素地址(内存实体地址)
// &a[i],a+i:数组默认从第0个开始进行索引划分(数组元素(内存实体)的标识符:索引)
// 2.数组元素本身(内存实体):
// a[i],*(&a[i]),*(a+i)
int main03(void)
//数组声明语法:double a[10];数组元素的类型 数组整体的名称[数组元素的个数];
double a[10] = 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0 ;
printf("%d \\n", sizeof(a));//10*8=80
for (int i = 0; i < 10; i++)
//&a[i], a + i;//代表数组第i个元素的内存实体地址,等价关系a+i(与类型密切相关)//以0作为开头
//a + (i - 1)*sizeof(double);//以1作为开头
//*号表示根据内存实体的地址获取内存实体本身(数据内容)
//a[i], *(&a[i]), *(a + i);//效果等价
printf("%lf, %lf, %lf, %p, %p \\n", a[i], *(&a[i]), *(a + i), &a[i], a + i);//下标,索引
system("pause");
///02.数组初始化语法.c
#include <stdio.h>
#include <stdlib.h>
//01.数组的初始化方式:
// 标准方式:
// int a[5] = 1, 2, 3, 4, 5;
// 数组元素的类型 数组整体的名称[数组元素的指明个数] = 静态初始化的静态数据;
// 简化方式:
// itn a[] = 1, 2, 3, 4, 5;
// 注意事项:
// 1.C/C++当中的静态数组必须进行静态初始化才能进行使用,Java当中的静态数组会进行默认初始化
// 大括号:就是表明静态初始化
// 2.数组的声明必须明确两点:数组元素的数据类型+数组元素的元素个数-->才能确定数组整体尺寸(内存字节数)
// 3.赋值特点:
// (1).大括号这种静态初始化方式,只能适用于声明数组的状态下(声明并定义的情况之下)
// (2).统一赋值与指明赋值特点:
// 统一赋值:0
// 指明赋值:
// 完全赋值:
// 1, 2, 3, 4, 5
// 前置局部:
// 1, 2, 3-->后面默认被编译器初始化为0,只有当前面进行了指明初始化的情况,后面才会进行默认初始化为0的操作
// 4.访问特点:
// 访问数组整体的内部某个元素本身(内存实体本身),不会出错
// 访问数组整体的外部某个元素本身(内存实体本身),可能出错,可能不出错(关键是看系统是否为该内存实体分配了使用权限)
int main04(void)
//int a[10] = 0 ;//C/C++当中的数组必须进行初始化
//int a[] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ;//明确数组初始化元素个数,可以省略数组元素个数的声明
//int a[10] = 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 ;//数组初始化不允许越界
//int a[10] = 1, 2, 3, 4 ;//默认没有初始化值的数组元素都将会被默认的初始化为0
int a[5] = 0 ;//数组必须明确其元素个数
for (int i = 0; i < 10; i++)
//注意不存在长度部分的数据将会是无法预料的值,5之后的数据可能会出现问题
printf("%d \\n", a[i]);
system("pause");
//02.数组名称的操作:
// 1.任何指针进行加法,乘法,除法都没有任何实际意义
// 2.在同一个数组当中的不同内存实体的内存地址进行
// 减法运算具备实际意义,用于获取两个数组元素之间的元素个数差值
// 3.C语言的常规数组不能进行整体操作,元素本身(内存实体)可以进行整体操作
// 4.C语言的特殊素组(字符数组),如果以'\\0'结尾,那么就是一个正常的字符串模拟
// 字符串结尾标识符必须是'\\0'(字符\\0)-->0或者'\\0'都一样
// 字符:'\\0'-->ASCII:0-->以及关键字NULL
int main05(void)
int a[5] = 1, 2, 3, 4, 5 ;
int b[5] = 2, 3, 4, 5, 6 ;
//a = b;//数组名称:标识数组整体的内存空间,数组名称是一个常量指针,不可以直接进行修改
//a[1];//访问整体数组a当中的第1个元素所对应的内存实体(数据本身)
//a + b;//C语言当中的普通数组不可以进行批量草最,只能针对于某一个元素进行批量操作
//a < b;
char str[5] = 'c', 'a', 'l', 'c', NULL ;
printf("%s \\n", str);
system("pause");
程序片段(02):01.数组.c+02.数组实战.c
内容概要:数组实战
///01.数组.c
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//01.数组越界问题分析;
// 1.采用数组名称访问内存实体的时候:
// 如果该内存实体位于数组整体当中的某个部分,那么访问正确
// 如果该内存实体位于数组整体外部的某个部分,那么访问出错
// 因为操作系统并没有为当前程序当中的数组分配该整体数组外部的内存实体的访问权限
// 2.C语言编译器的特点所导致:
// 数组不越界一定不会出错,数组越界可能会出错(编译通过但是运行不一定通过)
int main01(void)
//数组越界不一定出错,但是不越界一定不会发生内存访问冲突
int a[5] = 1, 2, 3, 4, 5 ;
for (int i = 0; i < 10; ++i)
printf("%d \\n", a[i]);//存在越界的情况,但是C语言的编译器不一定会进行报错
//当采用数组方式访问到别处内存地址所对应的内存实体(数据本身)的时候,可能会出现报错的情况:
// 因为该内存地址在赋值之前就已经具备了一定内存实体(数据本身),不允许紧急性数组操作
// 因为操作系统并没有为本程序分配该内存地址的使用权限
a[102389898] = 1;
system("pause");
int main02(void)
int a[10] = 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ;
for (int i = 9; i > -1; --i)
//逆序输出数组内存实体(数据本身)
printf("%d \\n", a[i]);
system("pause");
int main03(void)
int a[100] = 0 ;
time_t te = 0;
//unsigned int seed = (unsigned int)(time(&te));//获取随机数种子
//srand(seed);//种植随机数种子
srand((unsigned int)(time(&te)));
for (int i = 0; i < 100; i++)
//循环初始化方式(随机数)
a[i] = rand() % 300;
printf("%d \\n", a[i]);
int num = 0;
scanf("%d", &num);
int flag = 0;//假定找不到-->标识多数情况
for (int i = 0; i < 100; ++i)
if (a[num] == num)
flag = 1;//标识找到-->只要存在情况
break;
if (flag)
printf("找到! \\n");
else
printf("找不到! \\n");
system("pause");
///02.数组实战.c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
//01.最简单,最无效率的极值获取方式:
// 打擂算法:极值获取以及极值在数组当中所对应的索引
int main04(void)
time_t te = 0;
srand((unsigned int)(time(&te)));//获取并终止随机数种子
int a[20] = 0 ;
for (int i = 0; i < 20; ++i)
a[i] = rand() % 300;//通过随机数进行数组的赋值
printf("%d \\n", a[i]);
int minValue = a[0];
for (int i = 1; i < 20; ++i) //打擂算法:获取极小值
if (minValue > a[i])
minValue = a[i];
int maxValue = a[0];
for (int i = 1; i < 20; i++)//打擂算法:获取极大值
if (maxValue < a[i])
maxValue = a[i];
int minIndex1 = 0;
int minValue1 = a[0];
for (int i = 1; i < 20; i++)//打累算法:获取极小值以及极小值在数组当中所对应的索引
if (minValue1 > a[i])
minIndex1 = i;
minValue1 = a[i];
printf("minIndex1 = %d, minValue1 = %d \\n", minIndex1, minValue1);
system("pause");
//02.最简单的排序算法:
// 1.选择排序算法
// 2.时空复杂度分析:
// 时间复杂度:n平方
// 空间复杂度:1
#define EN 20
int a[EN];//C语言全局变量默认被初始化为0
int main05(void)
time_t te = 0;
srand((unsigned int)(time(&te)));//获取并种植随机数种子
for (int i = 0; i < 20; ++i)
a[i] = rand() % 300;//给数组进行进行随机数赋值
printf("%d \\n", a[i]);
printf("\\n");
int gtIndex = 0;
for (int i = 0; i < EN - 1; ++i)
gtIndex = i;
for (int j = i + 1; j < EN; ++j)
if (a[gtIndex] < a[j])
gtIndex = j;
if (i != gtIndex)
a[i] = a[i] ^ a[gtIndex];
a[gtIndex] = a[i] ^ a[gtIndex];
a[i] = a[i] ^ a[gtIndex];
for (int i = 0; i < 20; ++i)
printf("%d \\n", a[i]);
system("pause");
程序片段(03):main.c
内容概要:GccArray
#include <stdio.h>
#include <stdlib.h>
int main()
int num=10;
scanf("%d",&num);
int a[num];
//GCC支持动态分配数组:因此数组的元素个数指定可以采取变量,伪常量,真常量
//动态分配，运行的时候
return 0;
程序片段(04):冒泡排序.c
内容概要:冒泡排序法
#include <stdio.h>
#include <stdlib.h>
int main01(void)
int intArr[10] = 3, 5, 18, 9, 23, 5, 2, 1, 0, 2 ;
for (int i = 0; i < 10 - 1; ++i)
//冒泡法求最大值:两两临近的数据进行比较
if (intArr[i] > intArr[i + 1])
intArr[i] = intArr[i] ^ intArr[i + 1];
intArr[i + 1] = intArr[i] ^ intArr[i + 1];
intArr[i] = intArr[i] ^ intArr[i + 1];
printf("maxValue = %d \\n", intArr[9]);
system("pause");
int main02(void)
int intArr[10] = 3, 5, 18, 9, 23, 5, 2, 1, 0, 2 ;
for (int i = 0; i < 10 - 1; ++i)//外层循环,每完成一次循环,就有一个最值沉底
//冒泡法实现排序:重复进行相邻的两个数据比较
for (int j = 0; j < 10 - 1 - i; ++j)//沉底的次数,决定冒到了那里
if (intArr[j] > intArr[j + 1])//沉底
intArr[j] = intArr[j] ^ intArr[j + 1];
intArr[j + 1] = intArr[j] ^ intArr[j + 1];
intArr[j] = intArr[j] ^ intArr[j + 1];
for (int i = 0; i < 10; ++i)
printf("%d \\n", intArr[i]);
system("pause");
程序片段(05):斐波那契.c
内容概要:斐波那契数组法
#include <stdio.h>
#include <stdlib.h>
//01.斐波那契数列:
// 1.循环实现
// 2.递归实现
// 3.(循环+栈)实现
//02.数组的使用特点:
// 模拟栈这种数据结构
// 先进后出
// 模拟队列这种数据结构
// 先进先出
//03.如何进行递归加速?
// 递归-->循环+栈:可以实现递归加速
//04.三种实现斐波那契数列方式的速度问题:
// (循环+栈)>循环>递归
int fibonacciLoop(int nItem)
//循环实现:
if (1 == nItem || 2 == nItem)
return 1;
int temp1 = 1;
int temp2 = 1;
int nItemValue = 0;//初始化一个常数,效率更高
for (int i = 2; i < nItem; ++i)
nItemValue = temp1 + temp2;//存储推理结果
temp1 = temp2;//数据往前推进
temp2 = nItemValue;
return nItemValue;
int fibonacciRecursion(int nItem)
//递归实现:
if (1 == nItem || 2 == nItem)
return 1;
return fibonacciRecursion(nItem - 1) + fibonacciRecursion(nItem - 2);//关系表达式
int fibonacciLoopStack(int nItem)
//(循环+栈)实现:
int intArr[64] = 0 ;
intArr[0] = 1;
intArr[1] = 1;
for (int i = 2; i < nItem; ++i)//注意数组存储特点
intArr[i] = intArr[i - 1] + intArr[i - 2];
return intArr[nItem - 1];
int main01(void)
printf("loopResult = %d \\n", fibonacciLoop(40));
printf("recursionResult = %d \\n", fibonacciRecursion(40));
printf("loopStackResult = %d \\n", fibonacciLoopStack(40));
system("pause");
程序片段(06):迷宫1.c
内容概要:迷宫模拟
#include <stdio.h>
#include <stdlib.h>
void showIntArr(int intArr[10][10])
//显示二维数组
printf("------------------------------ \\n");
for (int i = 0; i < 10; ++i)
for (int j = 0; j < 10; ++j)
printf("%3d", intArr[i][j]);
printf("\\n");
printf("------------------------------ \\n");
//01.数组数据的存储特点:
// 1.所有数组的数据在内存当中的存储方式都是线性的
// 2.显式的结果不同是由于不同维度的数组对内存当中的数据的解析方式不同
int main01(void)
int intArr[10][10] = //二维数组的图形化初始化方式:将二维数组当做一维数组进行看待,该一维数组当中的每个元素就是一行的数据信息
0, 0, 0, 2, 0, 0, 0, 0, 0, 0,
0, 0, 2, 0, 0, 0, 0, 0, 0, 0,
0, 0, 2, 2, 2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0, 0, 0, 0, 0,
0, 0, 0, 0, 2, 0, 0, 0, 0, 0,
0, 2, 2, 0, 0, 0, 0, 0, 0, 0,
2, 0, 0, 0, 0, 0, 0, 2, 0, 2,
0, 2, 2, 0, 0, 0, 2, 2, 0, 0,
2, 0, 0, 2, 0, 2, 0, 0, 0, 0,
0, 0, 0, 0, 0, 2, 0, 2, 0, 0
;
showIntArr(intArr);
int px = 0, py = 0;//点坐标(默认:左上角(0,0)点)
intArr[px][py] = 1;//根据点坐标修改棋盘上对应点坐标的数据实体(二维平面的数据实体修改为0)
showIntArr(intArr);
char ch = '\\0';
while (1)
ch = getchar();
getchar();//吸收Enter键-->'\\n'-->'\\r\\n':Win解析
switch (ch)
case 'w'://按键控制
if (px - 1 >= 0 && intArr[px][py] != 2)
intArr[px][py] = intArr[px][py] ^ intArr[px - 1][py];
intArr[px - 1][py] = intArr[px][py] ^ intArr[px - 1][py];
intArr[px][py] = intArr[px][py] ^ intArr[px - 1][py];
--px;
break;
case 's':
if (px + 1 <= 9 && intArr[px + 1][py] != 2)
intArr[px][py] = intArr[px][py] ^ intArr[px + 1][py];
intArr[px + 1][py] = intArr[px][py] ^ intArr[px + 1][py];
intArr[px][py] = intArr[px][py] ^ intArr[px + 1][py];
++px;
break;
case 'a':
if (0 <= py - 1 && 2 != intArr[px][py - 1])
intArr[px][py] = intArr[px][py] ^ intArr[px][py - 1];
intArr[px][py - 1] = intArr[px][py] ^ intArr[px][py - 1];
intArr[px][py] = intArr[px][py] ^ intArr[px][py - 1];
--py;
break;
case 'd':
if (9 >= intArr[px][py + 1] && 2 != intArr[px][py + 1])
intArr[px][py] = intArr[px][py] ^ intArr[px][py + 1];
intArr[px][py + 1] = intArr[px][py] ^ intArr[px][py + 1];
intArr[px][py] = intArr[px][py] ^ intArr[px][py + 1];
++py;
break;
showIntArr(intArr);
system("pause");
程序片段(07):二分查找法.c
内容概要:二分查找法以及拉格朗日插值查找
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.二分查找法以及二分查找法的变形:
// 1.前提条件:待查找的数组当中的数据必须有序
// 最好是顺序排列的(从小到大进行排列)
// 2.二分查找以及拉格朗日查找:
// 拉格朗日查找用于二分查找的加速模式
#define N 1024
int binarySearch(int intArr[N], int value)
//二分查找法
int minIndex = 0;
int maxIndex = N - 1;
int midIndex = 0;
while (minIndex <= maxIndex)
midIndex = (minIndex + maxIndex) / 2;
if (value == intArr[midIndex])
return midIndex;
else if (value < intArr[midIndex])
maxIndex = --midIndex;
else
minIndex = ++minIndex;
return -1;
int lagrangeSearch(int intArr[N], int value)
//拉格朗日查找法
int minIndex = 0;
int maxIndex = N - 1;
//int midIndex = 0;
int tempIndex = 0;
while (minIndex <= maxIndex)
//midIndex = (minIndex + maxIndex) / 2;
//midIndex = minIndex + (maxIndex - minIndex) / 2;
tempIndex = minIndex + (value - intArr[minIndex]) / (intArr[maxIndex] - intArr[minIndex]);//二分查找加速
if (value == intArr[tempIndex])
return tempIndex;
else if (value < intArr[tempIndex])
maxIndex = --tempIndex;
else
minIndex = ++tempIndex;
return -1;
int main01(void)
int intArr[1024] = 0 ;
for (int i = 0; i < 1024; ++i)
intArr[i] = i;
int value = 0;
scanf("%d", &value);
printf("valueIndex = %d \\n", binarySearch(intArr, value));
printf("valueIndex = %d \\n", lagrangeSearch(intArr, value));
system("pause");
程序片段(08):插入排序法.c
内容概要:插入排序法
#include <stdio.h>
#include <stdlib.h>
int main01(void)
//插值法也要求数据必须有序
int intArr[10] = 1, 2, 3, 4, 6, 7, 8, 9, 10, 5 ;
int tempIndex = 9;
int tempValue = intArr[9];
while (tempIndex > 0 && intArr[tempIndex - 1] > tempValue)//从后往前进行插值
//tempIndex>0:由于要让索引-1,但是索引-1之后必须>=0因此索引必须>=1
//当此循环退出的时候,退出时所在的索引其实就是刚好需要进行插值的索引位置
intArr[tempIndex] = intArr[tempIndex - 1];
--tempIndex;
intArr[tempIndex] = tempValue;
for (int i = 0; i < 10; ++i)
printf("%3d", intArr[i]);
system("pause");
#define EN 10
void insertSort(int intArr[EN])
int tempIndex = 0;
int tempValue = 0;
//01.插值排序法说明:
// int i = 1:
// 当元素个数为1的时候,不需要插值排序算法
// 从1开始才能便于进行插值操作intArr[index-1]=intArr[index]
// i < 10:
// 从第一个元素开始,到最后一个元素都需要进行插值排序检测
// 注:忽略掉单个元素的数组,因为单个元素不存在插值排序
// tempIndex > 0:(可能插值移位的最大范围)
// 能够进行插值移位的前提
// intArr[tempIndex - 1] > tempValue:(可能插值移位的最小范围)
// 只要当前索引的前一个索引所对应的值大于待插入的值
// 就有必要执行插入操作
for (int i = 1; i < 10; ++i)
tempIndex = i;
tempValue = intArr[i];
while (tempIndex > 0 && intArr[tempIndex - 1] > tempValue)
intArr[tempIndex] = intArr[tempIndex - 1];
--tempIndex;
intArr[tempIndex] = tempValue;
int main02(void)
int intArr[EN] = 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 ;
insertSort(intArr);
for (int i = 0; i < EN; ++i)
printf("%3d", intArr[i]);
system("pause");
程序片段(09):开房.c
内容概要:开房数据检索-硬盘模式
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
char resourcesPath[256] = "D:\\\\Resource\\\\TestData\\\\DB\\\\KaiFang.txt";
char targetWritePath[256] = 0 ;
void selectResultWriteToTargetFile(char nameStr[256])
sprintf(targetWritePath, "D:\\\\Resource\\\\TestData\\\\Test\\\\%s.txt", nameStr);
FILE *frp = fopen(resourcesPath, "r");//以读取模式打开一个文件(硬盘直接读取模式)
FILE *fwp = fopen(targetWritePath, "w");//以写入模式打开一个文件(硬盘直接写入模式)
if (NULL == frp && NULL == fwp)
printf("建立文件指针失败! \\n");
return;
while(!feof(frp))//feof();到了文件读取的末尾返回真,没有到文件读取的末尾返回假
//只要没有到达文件读取的末尾,就继续进行硬盘文件读取操作
char readStr[1024] = 0 ;
fgets(readStr, 1024, frp);//硬盘模式读取一行数据(以换行符作为读取模式结束,并且长度仅限为1024)读取条件限制
char *tempStr = strstr(readStr, nameStr);
if (NULL != tempStr)
puts(readStr);//打印检索到的数据行
fputs(readStr, fwp);//硬盘模式写入到指定文件
fclose(fwp);//关闭文件写入流
fclose(frp);//关闭文件读取流
int main01(void)
char nameStr[256] = 0 ;
scanf("%s", nameStr);
printf("您要查询人的姓名是:%s \\n", nameStr);
time_t start = 0, end = 0;
time(&start);
selectResultWriteToTargetFile(nameStr);
time(&end);
printf("查询总计话费了%lf秒 \\n", difftime(end, start));
system(targetWritePath);
system("pause");
程序片段(10):二维数组.c
内容概要:二维数组
#include <stdio.h>
#include <stdlib.h>
//01.二维数组:
// 1.二维数组的内存存储原理:
// 所有数组,无论一维数组,二维数组,多维数组,在内存当中的
// 存储实质都是采取的连续存储方式
// 2.二维数组的规律赋值方式:
// 先进行行遍历,在进行列遍历,再逐个进行逐个数组元素的具体赋值操作
// 3.如何求取任何数组的内存尺寸?
// 都是采用sizeof();关键字进行的求取
int main01(void)
int a[5][5];
//1, 2, 3, 4, 5, 6, 7, 8, 9, 10:总共25个数组元素
printf("%d \\n", sizeof(a));//sizeof(数组名);-->求取数组整体的内存尺寸5*5*4
printf("%p \\n", a);
int num = 1;
for (int i = 0; i < 5; ++i)
for (int j = 0; j < 5; ++j)
//a[i][j] = num;
//++num;
//printf("%4d", a[i][j]);
printf("%4d", a[i][j] = num++);//复合语句
system("pause");
//02.二维数组知识详解:
// 1.初始化方式:
// 统一初始化:
// int a[5][4] = 0;-->巧用0
// 前置初始化:
// int a[5][4] = 1-->特用除0以外的数字
// 注:
// 1.统一初始化方式的实质还是前置初始化方式,由于采用特殊的数字
// 0进行初始化,所以整体被统一的初始化为了0
// 2.所有数组的初始化方式特点:
// 只要数组当中前置元素有数字前置初始化,那么后面的数组元素
// 本身都会被默认的初始化为0
// 2.多维数组的特殊初始化方式:
// 多维数组转化为低维数组进行初始化
// int a[5][4] =
// 1, 2,
// 1, 2, 3
// ;
// 3.确定数组内存尺寸的两大要素:
// 数组元素个数+数组元素尺寸
// 注:维度的省略情况分析:自动推演
// 以上是关于20160203.CCPP体系详解(0013天)的主要内容，如果未能解决你的问题，请参考以下文章