20160124.CCPP详解体系(0003天)

程序片段(01):HelloCGI.c

内容概要:CGI_HelloWorld

#include <stdio.h>
//01.CGI程序的编写规范
//  (1).HTML文本格式声明后面必须具备两个换行符
//  (2).不允许使用system();指令进行执行
int main(void)
{
    printf("Content-Type:text/html \n\n");//声明CGI文件在服务器当中以HTML语言格式进行解析
    printf("您好!天朝! \n");
    printf("<br />您不好!");
    //system("pause");
    return 1;
}

程序片段(02):printf.c

内容概要:printf();详解

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.printf();&sprintf();&fprintf();格式控制字符串详解:
//  (1).格式控制字符串的组成:
//      普通字符串+格式控制符
//  (2).常见的格式控制字符:
//      %f-->%lf-->%llf-->%e-->%g
//      %d/%i-->%ld-->%lld-->%u
//      %c-->%s
//  (3).格式控制字符只能对目标字符串进行左截取,不能
//      实现对目标字符串的右截取操作(无论是使用正负号)
//  (4).格式控制字符当中的点儿号(.)使用说明:
//      .号用于字符串映射,用于截取多少个字符(只能左截取)
//      .号用于实数映射,用于表示保留多少位小数
//      [注意:float类型的有效数字位数为6,7位,double类型的有效数字位数为22,23位]
//  (5 ).不同printf();函数的使用差别:
//      printf();-->打印到命令行|控制台|屏幕
//      sprintf();-->打印到字符串,常常用于待使用字符串的组装
//      fprintf();-->打印到文件
int main01(void)
{
    char inputstr[100] = { 0 };
    scanf("%s", inputstr);//输入,给字符串inputstr进行赋值操作
    char totalstr[100] = { 0 };
    sprintf(totalstr, "color %-.2s", inputstr);//字符串格式化打印,打印到目标字符串当中,将整数,实数,字符串整个到另外一个字符串当中
    system(totalstr);
    system("pause");
    //printf();-->sprintf();-->fprintf();
    return 1;
}
//01.凡是使用printf();&sprintf();&fprintf();函数打印的结果都是字符串:
//  (1).最终组装的打印结果就是字符串形式
//  (2).printf();函数系列说明:
//      printf();输出到命令行|控制台|屏幕|网页
//      sprintf();输出到字符串
//      fprintf();输出到文件
int main02(void)
{
    printf("Hello World!!! \n");//打印的最终结果是字符串
    printf("a = %d, str = %s \n", 10, "12345abc");//输出到命令行(网页),字符串,文件
    printf("c = %d", 10);
    system("pause");
    return 1;
}
//01.格式控制字符详细说明:
//  (1).正负号(+|-):
//      正号(+):表明右对齐,默认右对齐,映射字符串对齐方式
//  (2).是否是8进制形式数据:
//      是否指定填充0,默认填充空格,指定填充0
//  (3).有效整数部分指定打印的总体宽度
//      总体宽度大于实际宽度:
//          采取填充方式
//      总体宽度小于实际宽度:
//          显示实际宽度
//  (4).格式控制字符的截取效果体现:
//      1).只能体现于实数类型映射以及字符串形式的映射
//          针对于实数类型:体现意义为保留多少位小数(四舍五入)
//          针对于字符串型:截取多少个字符进行映射
//      2).截取效果只能是从左往右进行截取(无论正负号)
//  (5).点号的作用:
//      针对于实数类型:保留多少位小数(四舍五入)
//      针对于字符串型:截取多少个字符进行映射
int main03(void)
{
    printf("%d \n", 10);//有多宽分配多宽
    printf("%10d \n", 10);//总体宽度为10
    printf("%010d \n", 10);//右对齐,总体宽度为10,空余(左位置)指定填充(零)
    printf("%-10d \n", 10);//左对齐,总体宽度为10,空余(右位置)默认填充(空格)
    printf("%3d \n", 12345);//m整数,大于实际宽度,填充零(指定)或者空格(默认),否则无效
    system("pause");
    return 1;
}
int main04(void)
{
    printf("%.2f \n", 1.2345);//1.23
    printf("%.2f \n", 1.2355);//1.24
    char str[100] = "calc1";
    printf("%.4s", str);//保留小数点后多少位(实数类型数据),截取多少个字符(字符串类型)
    system("pause");
    return 1;
}
//01.int类型所占用字节数的特点:
//  (1).int类型占用字节数说明
//      16位机器上,int类型和short类型占用字节数一致,都是占用2个字节
//      32位以上的机器,int类型和long类型所占用的字节数一直,都是占用4个字节
//      但是,long类型无论是在16位机器还是32位以上的机器当中都是占用4个字节
//          所以常常使用long类型以替作int类型的拓展性
//  (2).整数类型的格式控制字符使用特点:
//      int-->%d
//      long-->ld
//      区分机器的特点,机器不同,那么解析方式不同,所以建议采用ld进行解析,比较正确一些
int main05(void)
{
    long l1 = 12345;
    printf("%d, %ld", l1, l1);
    system("pause");
    return 1;
}
//01.整数的格式控制字符说明:
//  (1).格式控制字符打印说明:
//      %d|%i-->有符号十进制输出
//      %u----->无符号十进制输出
//      %o----->八进制整数输出
//      %u----->十六进制整数输出
//  (2).有无符号的说明:
//      只针对于十进制的整数具备有无符号的说明
int main06(void)
{
    int num = -12345678;
    printf("%d \n", num);//有符号十进制
    printf("%i \n", num);//有符号十进制-->%d|%i效果完全一样
    printf("%u \n", num);//无符号十进制打印
    printf("%o \n",num);//整数八进制打印输出
    printf("%x \n",num);//整数十六进制输出
    system("pause");
    return 1;
}
//01.单个字符的输出特点:
//  将字符按照单个字符进行输出
//  将字符按照字符串进行输出
int main07(void)
{
    //如何输出单个字符?
    char ch = 'A';
    putchar(ch);//将字符按照字符进行输出
    printf("%c", ch);//将字符按照字符串进行输出
    char str[100] = "calc";
    printf("%s", str);//字符串输出
    system("pause");
    return 1;
}
int main08(void)
{
    char str[100] = { 0 };
    //%3c,该格式控制字符的目标是打印3个字符所组成的字符串,
    //  总共占用3个位置,其中单个字符占用一个位置,另外剩下两个左位置
    //sprintf(str, "color %c%3c", '4', 'f');//格式化:整数,实数,字符串整合到单个字符串当中
    //sprintf(str, "color %3c%c", '4', 'f');
    sprintf(str, "color %c%c", '3', 'f');
    system(str);
    printf("%s", str);
    system("pause");
    return 1;
}
//01.格式控制字符的使用特点:
//  (1).格式控制字符针对于字符串映射:
//      1).没有左右对齐概念(正负号+|-)
//      2).只有截取概念(点儿号.)
//  (2).格式控制字符针对于实数映射:
//      1).有左右对齐概念(正负号+|-)
//      2).有保留多少位小数概念(正负号+|-)
//          四舍五入的性质
int main09(void)
{
    char str[10] = "task";
    char newstr[10] = "123list123";
    printf("%p", newstr);
    char strall[100] = { 0 };
    //1.%s%s进行拼接
    //2.%.5%s截取,只能从左边开始进行截取(起始位置-->非指针操作)
    //3.从某一个地址开始从左往右进行截取(任意位置--->指针操作)
    //  10代表宽度
    //  负号(-)代表左对齐-->负号针对于字符串的截取无效
    sprintf(strall, "%s%.4s", str, newstr + 3);//字符地址的移动实现跳过某一丢段儿
    system(strall);
    printf("%s", strall);
    system("pause");
    return 1;
}
int main10(void)
{
    double db = 109.7896616253;
    printf("%.10f \n", db);//.10小数点后保留十位小数
    printf("%30.10f \n", db);//总共30位,保留十位小数(实际位数14位),剩余位数(16位),右对齐(左边儿补16个空格)
    printf("%-30.10f \n", db);//总共30位,保留十位小数(实际位数14位),剩余位数(16位),左对齐(右边儿补16个空格)
    printf("%030.10f \n", db);//总共30位,保留十位小数(实际位数14位),剩余位数(16位),右对齐(左边儿补16个零)
    //针对于实数类型右边儿是否补零却绝有保留的有效位数
    printf("%-030.10f \n", db);//总共30位,保留十位小数(实际位数14位),剩余位数(16位),左对齐(右边儿补16个零)-->
    system("pause");
    return 1;
}
//01.无论是实数还是小数按照%e进行输出:
//  1.其中保留的都是小数点后六位小数,需要进行四舍五入
//  2.%f进行打印的时候实际上也是进行了四舍五入的
//  3.概念区分:
//      有效数字(精确度)-->保留位数(四舍五入)
int main11(void)
{
    double db = 1045670500000;
    double dbs = 0.0000215001;
    printf("%e \n", db);//
    printf("%e \n", dbs);//指数输出(实数的输出格式)
    printf("%.8f", dbs);
    system("pause");
    return 1;
}
//02.用于打印实数的控制字符:
//  %f-->%e-->%g
int main12(void)
{
    //double db = 10456700000000;
    double db = 1.234567;
    printf("%f\n, %e\n, %g", db, db, db);//g自动选择宽度较短(%f|%e)的一个进行打印
    system("pause");
    return 1;
}
//03.格式控制字符当中没有%n这个控制字符
int main13(void)
{
    int num = 10;
    //printf("Hello %n china \n", &num);//%n禁用
    printf("num = %d", num);
    system("pause");
}

程序片段(03):main.c

内容概要:特殊格式控制符(printf();函数没有,scanf();函数有)

#include <stdio.h>
#include <stdlib.h>
//01.%n的使用特点:
//  1.printf();函数没有%n这个输出格式控制符
//  2.scanf();函数当中含有%n这个扫描格式控制符,
//    经常用在%s这种格式控制符的后面(紧跟)用于
//    统计数据扫描函数扫描的字符个数
int main01()
{
    int num;
    printf("h%n", &num);
    printf("num=%d", num);
    getchar();
}

程序片段(04):printf.c

内容概要:printf();函数补充

#include <stdio.h>
#include <stdlib.h>
//01.整数变量声明以及格式控制符使用:
//  (1).整数变量的声明方式:
//      1).所需描述的整数范围-->选择整数声明关键字(char->short->int->long->long long-->long double-->库扩展)
//      2).有符号,无符号-->实际意义-->更大的正整数范围
//      3).非简化形式,简化形式-->软件工程规范化
//  (2).整数
//      short int-->%hd|%hu
//      int-------->%d|%u
//      long int--->%ld|%lu
//      long long->%lld|%llu
// 注意事项:
//      在16位的机器当中
//          "short int"和int的意义一致
//              "short int" = int
//          "short int"和int的格式控制符意义一致
//              %hd = %d
//      在32位以上的机器当中
//          int和"long int"的意义一致
//          int和"long int"的格式控制符意义一致
//              %d=%ld
int main01(void)
{
    signed short int ssnum1 = 123;
    short int ssnum2 = 123;
    short ssnum3 = 123;
    unsigned short int usnum1 = 65535;
    unsigned short usnum2 = 65535;
    printf("ssnum1 = %hd, ssnum2 = %hd, ssnum3 = %hd, usnum1 = %hu, usnum2  = %hu \n", ssnum1, ssnum2, ssnum3, usnum1, usnum2);
    {
        signed long int slnum1 = 123;
        long int slnum2 = 123;
        long slnum3 = 123;
        unsigned long int ulnum1 = 65535;
        unsigned long ulnum2 = 65535;
        printf("slnum1 = %ld, slnum2 = %ld, slnum3 = %ld, ulnum1 = %lu, ulnum2 = %lu \n", slnum1, slnum2, slnum3, ulnum1, ulnum2);
    }
    printf("sizeof(long long) = %Id, sizeof(long double) = %Id \n", sizeof(long long), sizeof(long double));
    system("pause");
    return 1;
}
//02.整数的常量表现形式(进制形式)和输出控制符(进制形式)
//  (1).整数常量的表现形式(明确进制):
//      默认:十进制
//      0开头: 八进制
//      0x开头:十六进制
//  (2).整数的输出格式控制符(明确进制以及以及进制符号)
//      默认:十进制
//      %#o:八进制
//      %#x:十六进制
int main02(void)
{
    int num = 0127;
    printf("%o \n", num);
    printf("%#o \n", num);
    int data = 0x1234;
    printf("%x \n", data);
    printf("%#x \n", data);//一般情况之下,八进制和十六进制的格式控制符都会在中间插入井号"#",以明确的进制前缀输出
    system("pause");
    return 1;
}
//03.整数和实数的十六进制输出方式:
//  整数十六进制:%#x
//  实数十六进制:%a-->而且是指数形式
//  注意:科学计数法使用特点
//      十进制整数的底数是"e",十六进制整数的底数是"p"
int main03(void)
{
    float fl = (float)10.8;
    double db = 10.9;//long double等价于double
    //printf("sizeof(doube) = %lle, sizeof(long double) = %lle", sizeof(double), sizeof(long double));
    printf("%a \n", fl);//十六进制的显示方式
    printf("%a \n", db);
    //底数规律:e表示以10为底数,p表示以16为底数
    system("pause");
    return 1;
}
//04.控制符字母大小写和转义字符:
//  通常情况下,只有含有字母的数据才有控制字符的字母大小写对应
//      正整数的十六进制控制形式:%#x
//      实数的科学计数法形式:%e
int main04(void)
{
    //printf("%D \n", 10);//%d不可以大写
    //printf("%O \n", 010);//%o不可以大写
    //printf("%U \n", 10 );//%u不可以大写
    printf("%#X \n", 0x10);//x大小写决定了十六进制组成元素的大小写形式
    printf("%E \n", 10000000.0);//有字母输出的,可以大小写;没有字母输出的一般不可以(%o例外)
    //printf("");需要精确匹配
    printf("\"123\" \n");//转义字符
    printf("\'123\' \n");
    printf("\n 55%% \n");;
    system("pause");
    return 1;
}
//05.printf();一定要进行匹配,防止数据错误
// printf();和逗号表达式的效果结合
//      参数列表多了,按照格式控制符的个数进行对应
//      参数列表少了,按照格式控制符的个数少的地方补上编译器指定垃圾值(随机)
int main05(void)
{
    //printf("%d, %d \n", 1, 2, 3);
    //printf("%d, %d, %d, %d \n", 1, 2, 3);
    //printf("%d, %d, %d, %d, %d, %d, %d \n", 1, 2, 3);
    system("pause");
    return 1;
}
//06.将实数按照小数点儿后1位到N位的打印语句:
//  printf("%*.*f \n", i + 2, i, db);
//      第一颗星:
//          最初长度为2(1占用一个位置+"."占用一个位置)
//          对应参数i+2,因为i是从1开始的,意味着总宽度从3开始增长,输出总宽度从2开始变宽
//      第二颗星:
//          保留多少位小数(数据提取精度,不是原始数据精度)
//          保留小数位数从1开始逐渐递增
//      最后的f:
//          表示原始实数数据
//  *号用于占位,用于控制实数的输出形式
int main06(void)
{
    double db = 1.123456789123456789;
    for (int i = 1; i < 20; i++)
    {
        printf("%*.*f \n", i + 2, i, db);//让小数点位置变动的变化
    }
    system("pause");
    return 1;
}
//07.点儿星(.*)在控制字符串(printf();)中的作用:
//  用于实数输出的时候,表示保留多少位小数(精度)
//  用于字符串输出的时候,提取前多少个字符进行输出
int main07(void)
{
    char str[100] = "1234567890qwertretrertert";
    for (int i = 1; i < 10; i++)
    {
        printf("%.*s \n", i, str);//控制宽度,小数点儿,变元
    }
    system("pause");
    return 1;
}

程序片段(05):scanf.c

内容概要:scanf();函数详解

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.scanf();函数扫描输入事项:
//  格式必须一一匹配:非格式控制符的可见字符必须一一匹配输入
int main01(void)
{
    int num = 0;
    printf("%p \n", &num);
    scanf("num=%d", &num);//根据地址对变量进行赋值初始化
    printf("num=%d \n", num);
    system("pause");
    return 1;
}
//02.星号(*)用于scanf();和printf();当中的不同特点:
//  用于scanf();当中可以跳过该格式控制符所对应的数据挖掘
//  用于printf();当中可以控制总输出宽度以及以及保留小数位数(精度)
int main02(void)
{
    int a, b = 0, c;
    scanf("a=%d,b=%*d,c=%d", &a, &c);
    a = a + 1;
    //b = b + 10;
    printf("a=%d,b=%d,c=%d readall", a, b, c);
    system("pause");
    return 1;
}
//03.关于scanf("%d%d%d");形式的整数录入特点分析
//  (1).不可见字符间隔:空格,Tab键,回车
//  (2).解析特点:
//      1).scanf();字符串缓冲区-->格式字符串映射进去
//      2).格式控制符进行数据挖掘
//          进行数据类型匹配挖掘
//      3).不可见字符用于发出挖掘指令
int main03(void)
{
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    printf("a = %d, b = %d, c = %d readall \n", a, b, c);
    system("pause");
    return 1;
}
int main04(void)
{
    int num;
    char str[100] = { 0 };
    scanf("%d %s", &num, str);//中间的不可见字符:可以采用空格+Tab键+回车发出挖掘指令(从scanf();的控制字符串缓冲区当中挖掘)
    printf("num = %d, str = %s", num, str);
    system("pause");
    return 1;
}

程序片段(06):scanf.c

内容概要:scanf();函数拓展

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define 海华中意的身高 172
#define 海华中意的年龄 30
//01.数据挖掘含义:
//  1.数据扫描函数从指定字符串当中挖掘有用信息到指针列表当中所指向变量位置
//  2.然后对该指针所指向的变量数据进行各种操作
//02.数据扫描函数使用注意事项:
//  格式控制符所对应的数据左右
//      无论有多少个空格
//      无论有多少个Tab键
//      无论有多少个回车
//  都只当做一个空格进行数据扫描处理
int main01(void)
{
    char str[500] = "131610 陈小姐 女    40 165 高中  未婚  朝阳  双子座 在校学生    普通话 北京  面议元/天   有过几次    学生伴游    清纯漂亮 自信可爱的我独在北京上学.在这浪漫的季节偶尔来到这里寻找我的有缘人.愿我们的相聚能留下人生中最美好的回忆!  10:00—23:00     2264938779@qq.com       226493870779";
    int tall;
    int age;
    sscanf(str, "%*d %*s %*s %d %d", &age, &tall);//数据挖掘
    //三元运算符-->三元表达式-->当中只有一个分号,那就是结尾的那个用于语句结束的分号";"
    (age >= 海华中意的年龄) && (tall <= 海华中意的身高) ? printf("海华买单 \n") : printf("换下一个 \n");
    system("pause");
    return 1;
}
//01.如果一个字符串的前后含有逗号","都会被字符串格式控制符识别为字符串组成元素:
//  (1).空格形式的不可见字符不会被识别为组成元素
//  (2).数字形式的课件字符不会被识别为组成元素
int main02(void)
{
    //%s，
    char str[500] = "420111197203024016,13600477059,nixiaodong@vip.sina.com";
    //字符串不会将逗号当做一个结束
    long long selfid;
    long long mobile;
    char email[100] = { 0 };
    //,|%|#不能作为字符串结尾符,需要进行数据扫描挖掘的提前替换
    sscanf(str, "%lld,%lld,%s", &selfid, &mobile, email);//从字符串当中进行数据挖掘操作
    printf("%lld,%lld,%s \n", selfid, mobile, email);
    system("pause");
    return 1;
}
int main03(void)
{
    char str[500] = "刘海华,420111197203024016,13600477059,niniaodong@vip.sina.com";
    //将障碍字符串数据扫描的可见字符串组成元素进行替换,以待后期的数据扫描挖掘
    for (int i = 0; i < 500; i++)
    {
        if (str[i] == ',')
        {
            str[i] = ' ';
        }
    }
    char name[100] = { 0 };
    long long selfid;
    long long mobile;
    char email[100] = { 0 };
    sscanf(str, "%s %lld %lld %s", name, &selfid, &mobile, email);
    printf("%s %lld %lld %s \n", name, selfid, mobile, email);
    system("pause");
    return 1;
}
int main04(void)
{
    char str[150] = "530981645----13707700754aini";
    long long QQ;
    char pass[100] = { 0 };
    sscanf(str, "%lld----%s", &QQ, pass);
    printf("QQ = %lld, pass = %s \n", QQ, pass);
    system("pause");
    return 1;
}

程序片段(07):scanf.c

内容概要:scanf();函数加强

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.连续整数的截断技巧:
//  1.%d控制整数数据扫描挖掘
//  2.中间插入数字(%Nd)表示按照多少个数字组成进行阶段挖掘
int main01(void)
{
    int a, b, c, d, e;
    scanf("%3d%3d%3d%3d%3d", &a, &b, &c, &d, &e);//3指定整数的挖掘长度
    printf("a = %d, b= %d, c = %d, d = %d, e = %d \n", a, b, c, d, e);
    system("pause");
    return 1;
}
//02.scanf();函数使用细节说明:
//  1.星号(*)表示跳过该格式控制符所对应的数据扫描
//  2.整数从某个字符串数据开始连续扫描多少个数据
int main02(void)
{
    char str1[100] = { 0 };
    char str2[100] = { 0 };
    scanf("%*3s%5s", str1, str2);//固定长度截取,*忽略
    printf("%s, %s \n", str1, str2);
    system("pause");
    return 1;
}
//03.实数的扫描不可以指定精度,打印可以指定精度
//  扫描的精度指定无效
int main03(void)
{
    float fl = 0;
    scanf("%7f", &fl);//实数不可以指定精度
    printf("fl = %lf \n", fl);
    system("pause");
    return 1;
}
//04.数据扫描函数是用于将数据扫描的指针所指向的变量当中
int main04(void)
{
    int num = 0;
    scanf("%d", &num);//不写地址符,会将整数的值当做地址进行处理
    system("pause");
    return 1;
}
//05.数据扫描函数要求格式一一对应才行
int main05(void)
{
    int num = 0;
    scanf("#num=%d", &num);//精确匹配,不可以遗漏
    printf("%d", num);
    system("pause");
    return 1;
}
//06.即使是不可见字符也会被当做字符的有效输入:
//  (1).空格-->Tab键-->回车
//  (2).有效输入就能有效输出
int main06(void)
{
    char ch1, ch2, ch3;
    scanf("%c%c%c", &ch1, &ch2, &ch3);
    printf("[%c][%c][%c] \n", ch1, ch2, ch3);//回车会被当做一个有效输入
    system("pause");
    return 1;
}
//07.不同格式控制符所对应的数据扫描结束点不同:
//  字符串的输入格式控制符以:
//      必须以不可见字符空格,Tab键,回车进行结束
//  数字的输入格式控制符:
//      除了数字以外的任何字符
int main07(void)
{
    int num1;
    int num2;
    int num3;
    char str[100];
    scanf("%s%d%d%d", str, &num1, &num2, &num3);
    printf("%s, %d, %d, %d \n", str, num1, num2, num3);//字符串必须以空格或者回车结束
    system("pause");
    return 1;
}
int main08(void)
{
    int num1;
    int num2;
    int num3;
    //1.在scanf();函数当中,%%代表一个实际的%
    //2.注意%d%%必须得挨着才行,否则会数据扫描失败
    //  1).数据扫描和数据匹配是两码事儿
    //  2).%%不可以挖掘到整数,所以必须连在一起
    scanf("%d%%%d%d", &num1, &num2, &num3);
    printf("%d,%d,%d \n", num1, num2, num3);
    system("pause");
    return 1;
}
//08.scanf();数据扫描函数使用技巧:
//  在进行使用格式控制符进行字符串数据扫描的时候
//  如果在扫描字符串格式控制符的末尾添加一个%n
//  就意味着可以统计挖掘到的字符串当中的字符个数
int main09(void)
{
    int num1;
    int num2;
    int num3;
    char str[100];
    int n;
    scanf("%s%n%d%d%d", str, &n, &num1, &num2, &num3);//统计字符数量
    printf("%s,%d,%d,%d \n", str, num1, num2, num3);//字符串必须空格或者回车以及Tab键以作结尾
    printf("n = %d \n", n);
    system("pause");
    return 1;
}
//09.数据扫描函数与正则表达式的结合常常用于对字符串
//  的处理
int main10(void)
{
    char str[100];
    //scanf("%s", str);
    //scanf("%[^\n]", str);//只有\n才会被当做为数据扫描挖掘的结尾
    //scanf("[A-Z]%n", str);//只有\n当做结束
    //printf("%s \n", str);
    system("pause");
    return 1;
}

程序片段(08):getchar&gets.c+putchar&puts.c

内容概要:字符字符串函数

///getchar&gets.c
#include <stdio.h>
#include <stdlib.h>
//01.gets();函数说明:
//  1.可以直接提取含有空格的字符串
//      scanf();默认以空格|Tab键|回车结束结束字符串扫描
//  2.函数特点是将函数提取到的数据从该函数当中带出来
//      通做指针进行数据的带出,跨函数访问内存
//02.putchar();只能输出单个字符
//  1.如果是字符常量,就必须采用单个字符的标识符单引号('')
//  2.putchar('');这样不行,putchar(' ');putchar('\0')等效
int main01(void)
{
    char str[100];
    //gets(str);//直接输入初始化一个字符串
    //printf("%s", str);
    //system(str);
    char ch = getchar();
    putchar(ch);
    system("pause");
    return 1;
}

///putchar&puts.c
#include <stdio.h>
//#include <stdlib.h>
//01.puts();函数详解:
//  1.puts();函数末尾会自动携带回车,不同于putchar();和printf();
//  2.puts();函数用于字符串的原样输出
//02.putchar();函数详解:
//  1.既可以输出字符常量,也可以输出字符变量,还可以输出结果为整数的表达式
//      字符常量:用单引号('')进行标识
//      字符变量:
//      整数表达式:
//  2.大小写英文字分母的转换:
//      大写转小写:大写+32
//      小写转大写:小写-32
int main01(void)
{
    puts("Content-Type:text/html \n\n");//代表网页HTML开头
    puts("1234<br />");//自动换行
    puts("1234<br />");//输出字符串,网页用<br />
    putchar('A');
    putchar(65);
    putchar('A' + 32);
    //system("pause");
    return 1;
}

程序片段(09):赋值运算符.c

内容概要:赋值运算符

#include <stdio.h>
#include <stdlib.h>
//01.无符号存储特点:
//  1.所有二进制位全部当做数据进行解析,不考虑符号位的影响
//  2.解析的时候必须采用无符号数据所对应的格式控制符解析
//      防止将无符号的数据位解析为有符号,会造成负数(负的很大数出现)
//02.赋值运算符特点:
//  1.标准赋值运算符
//  2.复合赋值运算符
//03.位运算操作特点:
//  1.由于是直接操作内存当中的二进制位,所以运算效率极其高
//  2.位运算用图形化进行解释比较恰当
int main01(void)
{
    unsigned char ch1 = 1;//0000 0001
    unsigned char ch2 = 3;//0000 0011
    ch1 &= ch2;//ch1=ch1&ch2;//将寄存器的运算结果赋值给内存当中的变量
    ch1 |= ch2;
    ch1 ^= ch2;//ch1=ch1^ch2;
    ch1 <<= ch2;
    ch1 >>= ch2;//复合赋值运算符
    printf("%d \n", ch1);
    system("pause");
    return 1;
}
//04.所有对变量的操作,只要没有对原始变量进行赋值运算符(包括复合赋值运算符)的操作
//  就不会修改原始变量在内存当中的数据,使用变量的实质是使用变量当中所存储的数据
int main02(void)
{
    unsigned char ch1 = 1;//0000 0001
    unsigned char ch2 = 3;//0000 0011
    unsigned char ch3 = ch1 & ch2;//位运算没有改变原有变量的值,只是提取原来的数据在内存中用于计算
    system("pause");
    return 1;
}

程序片段(10):位与.c+位或.c+位异或.c+位反.c+左移.c+右移.c

内容概要:位运算

///位与.c
#include <stdio.h>
#include <stdlib.h>
//01.位与运算符的使用特点:
//  1.&-->位与
//      00 0
//      01 0
//      10 0
//      11 1
//  2.位与运算符特点:
//      只有两个进行位与运算的二进制位同为1的时候,结果为1
//  3.位与运算符的实际应用:
//      任何二进制位位与上一个0,其二进制位与运算的结果都会变成0
//              XXXX
//          &   0000
//              0000
//      任何二进制位位与上一个1,期二进制位与运算的结果都会保留原二进制位
//              XXXX
//          & 1111
//              XXXX
int main03(void)
{
    unsigned char ch = 255;//1111 1111
    unsigned char nch = 15;//0000 1111
    unsigned char rch = ch & nch;
    printf("%d \n", rch);//这里含有判断变量符号的解析特性
    system("pause");
    return 1;
}

///位或.c
#include <stdio.h>
#include <stdlib.h>
//01.位或运算符的使用特点:
//  1.|-->位或
//      00 0
//      01 1
//      10 1
//      11 1
// 2.位或运算的特点:
//      任何两个二进制位进行位或运算,只要其中有一方为1,那么结果就为1
//  3.实际应用:
//      任何二进制位位或上一个0,其二进制位都会保留下来
//              XXXX
//          |   0000
//              XXXX
//      任何二进制位位或上一个1,其二进制位都会变成1
//              XXXX
//          |   1111
//              1111
int main04(void)
{                 
    system("pause");
    return 1;
}
//02.无符号类型的数据解析特殊性:
//  1.在采用一个字符存储单位存储的无符号数据会被当做无符号内容进行解析
//  2.前提条件是待解析的变量是无符号类型,解析结果为255
//  原因:将单字节内存数据往高字节内存存储,最高位会补上符号位(有符号的情况之下)
//      无符号的情况之下,这里没有进行符号位的补充
int main05(void)
{
    unsigned char ch = 255;//1111 1111
    unsigned char nch = 15;//0000 1111
    unsigned char rch = ch | nch;
    printf("%d \n", rch);//这里很特殊,将无符号的1111 1111按照%d进行解析,结果却是无符号的解析结果255
    //这里默认隐含有判断有无符号变量的特性,而且具有数据类型提升的特点
    system("pause");
    return 1;
}

///位异或.c
#include <stdio.h>
#include <stdlib.h>
//01.异或运算符的使用特点:
//  1.^-->异或
//      00 0
//      01 1
//      10 1
//      11   0
//  2.异或的特点:
//      只要两个二进制位不一样,那么进行位异或运算的结果就为1
//      只要两个二进制位一样,那么进行位异或运算的结果就是为0
//  3.异或的实际应用:
//      最有效的交换两个变量的数据原理
int main06(void)
{
    int a = 10;//0000 1010
    int b = 20;//0001 0100
    printf("a = %d, b = %d \n", a, b);
    /*
        a 0000 1010-->原始a
        b 0001 0100-->原始b
    ^  a 0001 1110
        b 0001 0100
    ^  b 0000 1010-->最终b
         a 0001 1110
    ^  a 0001 0100-->最终a
    */
    a = a ^ b;
    b = a ^ b;
    a = a ^ b;
    printf("a = %d, b = %d \n", a, b);
    system("pause");
    return 1;
}
int main07(void)
{
    unsigned char ch = 255;//1111 1111
    unsigned char nch = 0;
    unsigned char rch = ch ^ nch;
    printf("%d \n", rch);//1111 1111-->255
    //printf();只会进行尝试类型转换!
    //  1.判断变量的有无符号性
    //  2.判断有无符号,在进行类型尝试提升:
    //      有符号,补上符号位
    //      无符号,不补符号位
    system("pause");
    return 1;
}
int main08(void)
{
    unsigned char ch = 255;//1111 1111
    unsigned char nch = 15;//0000 1111
    unsigned char rch = ch ^ nch;
    printf("%d \n", rch);//尝试数据类型的转换
    system("pause");
    return 1;
}

///位反.c
#include <stdio.h>
#include <stdlib.h>
//01.打印函数对于控制符的特殊解释:
//  1.如果格式控制符的解析方式指定的解析数据字节数
//      大于待解析的数据所占用的字节数,就会出现尝试类型转换的特点
//  2.先判断原始变量的符号特性:
//      如果有符号,按照符号特性进行提升-->按最高位进行
//      如果是无符号,不按照符号特性提升-->补0
//  3.最后进行数据的格式控制符进行解析
int main09(void)
{
    printf("%d \n", sizeof(1));
    //0000 0000 0000 0000 0000 0000 0000 0001 +1原码
    //1111 1111 1111 1111 1111 1111 1111 1110 - 1原码
    unsigned char a = ~1;//取反,产生了截断-->截断成为了单个字节,所有二进制位都是1
    unsigned int b = ~1;//取反,一共三个字节,所有位二进制位都是1
    /*
    0000 0001
    1111 1110
    */
    printf("%d \n", a);
    printf("%u \n", b);
    system("pause");
    return 1;
}

///左移.c
#include <stdio.h>
#include <stdlib.h>
//01.左移位运算符的使用特点:
//  1.<<-->左移位
//      0001-->1000
//  2.左移位的特点:
//      移出的最高位进行舍弃,最低位补0
//  3.左移位的实际应用:
//      (1).用于提升数据的运算效率
//      (2).将十进制数据的乘2运算
//           转换为左移位运算,将会提升运算效率
int main10(void)
{
    unsigned int a = 1;
    //0000 0001   1
    //0000 0010   2
    //0000 0001 1
    //1000 0000  128
    //1111 1111 255
    //1111 1111 1 256越界
    printf("%d \n", a << 1);//左移一个二进制位相当于原始数据乘以2的一次方
    printf("%d \n", a << 2);
    printf("%d \n", a << 3);
    printf("%d \n", a << 4);
    printf("%d \n", a << 5);
    printf("%d \n", a << 6);
    printf("%d \n", a << 32);//
    system("pause");
    return 1;
}

///右移.c
#include <stdio.h>
#include <stdlib.h>
//01.右移位运算符的使用特点:
//  1.>>-->右移位
//      1000-->0001
//  2.右移位的特点:
//      将十进制数的二进制位向右移动移位,相当于该十进制数除以2
//  3.右移位运算的实际应用:
//      提升十进制数做2的除法运算的替换法则,有利于运算效率的提升
int main11(void)
{
    int a = 100000;//0000 0001
    //0000 0000 1
    //右边移动等价于除以2,整除
    printf("%d \n", a >> 1);
    printf("%d \n", a >> 2);
    printf("%d \n", a >> 3);
    printf("%d \n", a >> 4);
    printf("%d \n", a >> 5);
    printf("%d \n", a >> 6);
    printf("%d \n", a >> 7);
    system("pause");
    return 1;
}

程序片段(11):内存.c

内容概要:内存实体

#include <stdio.h>
#include <stdlib.h>
//01.寄存器当中所执行的操作:
//  1.表达式是在寄存器当中
//  2.常量是在寄存器当中
int main01(void)
{
    //1 + 2 = 3;
    const int a = 10;
    a + 1 = 20;//寄存器
    a = 10;
    system("pause");
    return 1;
}

程序片段(12):res.c

内容概要:printf();&scanf();返回值详解

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.printf();函数的返回值:
//  1.正确打印出的字符个数
//  2.统计字符个数的时候,不是按照格式控制符进行统计的
//      是实际打印出的结果:例如%d--->12-->就是两个字符
int main01(void)
{
    int num = printf("12345");
    printf("\n %d \n", num);//纯字符串的情况之下,返回值是字符的个数
    system("pause");
    return 1;
}
int main02(void)
{
    int num = printf("a = %d, b = %d \n", 10, 12);
    printf("\n %d \n", num);
    system("pause");
    return 1;
}
//02.scanf();函数的返回值:
//  1.表示多少个格式控制符对应的数据提取成功
//  2.一个格式控制符提取成功+1
int main03(void)
{
    int a;
    int b;
    int c;
    int num = scanf("%d%d", &a, &b);
    printf("num = %d \n", num);//scanf的返回值表示成功抓取到的数据个数
    system("pause");
    return 1;
}

程序片段(13):scanf.c

内容概要:scanf();&正则表达式

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
//01.scanf();函数使用特点:
//  1.默认扫描结束标识符:
//      空格,Tab键,回车被当做为默认的数据扫描结束指令
//  2.采用正则表达式进行任意指定结束标识符
//      正则表达式:"%[^结尾标识符]"
int main01(void)
{
    char str[100] = { 0 };
    //scanf("%s", str);//空格,Tab键,回车当做结束
    //scanf("%[^\n]", str);//处理空格,Tab键,回车
    //scanf("%[^,],str");
    scanf("%[^,]", str);//,#=作为结束符
    printf("str = %s \n", str);
    system("pause");
    return 1;
}
//02.scanf();函数与正则表达式的结合使用特点:
//  1.正则表达式的特点解析:
//      遇到第一个不是XXXX的就结束数据扫描操作
//          %[XXXX]
//      遇到第一个是XXXX的就结束数据扫描操作
//          %[^XXXX]
//  2.指定扫描的数据类型
//      只能是数字%[0-9]
//      只能是字母%[a-zA-Z]
int main02(void)
{
    char str[100] = { 0 };
    //scanf("%[1]", str);//遇到第一个不是1的字符就结束数据扫描操作
    //scanf("%[A-Z]", str);//遇到第一个不是A-Z之间的字符就结束数据扫描操作
    //scanf("%[^A-Z]", str);//遇到第一个是A-Z之间的字符就结束数据草庙操作
    //scanf("%[a-zA-Z]", str);
    scanf("%[0-9a-zA-Z]", str);
    printf("str = %s \n", str);//电话只有数字
    system("pause");
    return 1;
}

程序片段(14):run.c

内容概要:内存实体以及运算符优先级

#include <stdio.h>
#include <stdlib.h>
//01.常量内容解析:
//  1.常量的分类:
//      宏常量:真正意义上的常量
//          不具备内存实体;
//          既不能直接赋值,也不能间接赋值
//      常变量:一般意义上的常量
//          具备内存实体
//          不能直接赋值,但是可以间接赋值
//      划分标准:
//          宏常量不具备内存实体
//          常变量具备内存实体
//  2.对内存实体的赋值注意事项:
//      要看指针的类型特点:
//          const修饰的指针不能修改内存实体
//          非const修饰的指针可以修改内存实体
//  3.是否具备内存实体是区分左值和右值的关键
//      左值一定可以出现在赋值号的左边,一定可以出现赋值号的右边
//      右值一定可以出现在赋值号的右边,但是不一定可以出现在赋值号的左边
int main01(void)
{
    int a;
    a = 10;
    //能取内存的地址,有内存实体
    const int b = 10;
    //b = 10;//左值指定const对象
    *(int *)&b = 12;//define const只能保证不能直接赋值,但是不能保证不能进行间接赋值,通过变量地址可以进行赋值
    printf("%d \n", b);
    //a + 1 = 1;
    //3 + a = 2;
    //printf("%p \n", &a);
    int * p = &a;
    int *p1 = &b;
    system("pause");
    return 1;
}