2014.3.4-C语言学习小结

位操作:

知识点:
1.位运算符
2.位移运算符

1.将指定位设置为1
2.将指定位设置为0
3.获取指定位的内容

==========================
复习二进制
1.二进制转换
10--> /2 取余数 1010
2.原码,反码,补码
-1 0xffffffff %d %#x %#o

3.二进制高位和低位
0000 0001
4.二进制输出函数
1010
==========================
位操作
1.什么是位操作
位操作是程序设计当中对位模式按位或二进制数的一元和二元操作.
在许多古老的微处理器上, 位运算比加减运算略快, 通常位运算比乘除法运算要快很多.
在现代架构中, 情况并非如此:位运算的运算速度通常与加法运算相同(仍然快于乘法运算).
2.作用
1)加快某些算术元素操作,例如乘法和除法使用位移效率较高
2)标志位设置
==========================
位运算符

1.位运算符
<< , >>, &, |, ~, ^
1)对比逻辑运算符 &&, ||, !
2.位与操作 &
1)按位&运算符的运算方法
按顺序,每一位进行比较,如果两位都为1,结果为1,相反为0
2)十六进制表示二进制
4)作用:
1.清空某一位
2.获取某一位
示例:
0&0, 1&0, 0&1, 1&1

-1 & 1
练习:
1.手工运算,然后程序验证:
1010 1100 & 1110 0111 164—>0xa4

1110 1101 & 1010 0101 165->0xa5

 

3.位或操作 |
1)按位|运算的运算方法
对应位只要一个为1,结果为1,如果都为0,结果为0
练习:
1.手工运算,然后程序验证:
1010 1100 | 1110 0111 239
1110 1101 | 1010 0101 237



& 0 1
0 0 0
1 0 1

| 0 1
0 0 1
1 1 1



4.位取反 ~
1)位取反运算方法
所有位按位取反
2)注意取反结果
练习:
手工运算,然后程序验证:
1.~11011111 0xffffff20
2.~-1

5.位异或(xor) ^
1)运算方法
对应位不同为1,相同为0
^ 0 1
0 0 1
1 1 0

练习:
手工运算,然后程序验证
1. 1 ^ 1, 1 ^ 2, 1 ^ 3
2. -1 ^ 10

两数交换的位操作版本
===========================
位移操作 2^n
|0000 0001|

1.左移运算符 <<
1)运算方式
高位移出位舍弃,低位补0
示例:
1111 0001 << 1
练习:
手工运算,然后程序验证
1. 1 << 0, 1 << 1, 1 << 2, 1 << 3
2. -1 << 1
1 << 31

|0000 0010| |1111 1000|
|0000 0001| |1111 1100|0
|0000 0000|1 |1111 1110|00

0000 0001 >> 1 1 / 2 1%2

2.右移运算符 >>
1)运算方式
1>无符号右移 unsigned
高位补0
2>有符号右移 -2 2
移出位舍弃,高位补符号位
练习:
手工运算,然后程序验证
1. 1 >> 0,1 >> 1, 4 >> 1, 8 >> 1
2. -10 >> 1
-5 >> 1

========================================
应用示例:
1.指定位清0
思考:如何设置第n位为0
n & ~(1 << num)
练习:定义一个函数,作用为设置指定为0
函数原型:int set0(int n, int num)
2.指定位设置为1
思考:如何设置第n位为1
n | (1 << num)
练习:定义一个函数,作用为设置指定位为1
函数原型:int set1(int n, int num)
3.获取某一位的值

n >> num & 1
00000000
思考:如何可以获取指定位的值
练习:定义一个函数,作用为获取某一位的值
函数原型:int get_bits(int n, int num)
4.二进制转换函数
思考:如何利用位操作可以获取到一个数的二进制
函数原型:void binshow(unsigned int n, int size)
=========================================
扩展
1.如何循环左移或者右移int的所有位
1 2 3 4 5
5 1 2 3 4 unsigned
1010
0101
1010
2.利用位操作实现简单的加密解密功能
^

 

练习:

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
#include <stdio.h>
 
int set0(int num, int n)
{
    return num & ~(1 << n);
}
int set1(int num, int n)
{
    return num | (1 << n);
}
int getbits(int num, int n)
{
    return num >> n & 1;
 
//  return num & (1 << n) != 0 ? 1 : 0;
/*
    int res = num & (1 << n);
    if (res != 0)
    {
        return 1;
    }
    return 0;
*/
}
//显示一个数的所有二进制
void binshow(int num, int len)
{
    int i = 0;
    int ret = 0;
    for (i = len - 1; i >= 0; --i)
    {
        ret = num >> i & 1;  
        printf("%d", ret);
    }
    printf("\n");
 
}
 
int main(int argc, char *argv[])
{
    int num = 10;//1010 & 1101
 
    int n = 1 << 1; //0010
 
    int status = num & n; //获取某个位的状态
 
    n = 1 << 2;//0100
    status = num | n;//设置某个位的状态为1
 
    n = ~(1 << 3);//0111
    status = num & n; //将某一位设置为0
 
//00000000101110111111100011001011
    binshow(12318923, 32);
 
    return 0;
}

  

知识点:
1.字符和字符处理函数
2.字符串的本质和字符串输入输出函数
3.字符串转换函数
4.常用字符串处理函数
5.字符串查找函数
6.字符串分割函数
7.字符串替换
8.常用字符串处理函数实现
9.sscanf函数
=================================
字符和字符处理
1.复习ascii码
‘0‘~‘9‘ ‘a‘~‘z‘ ‘A‘~‘Z‘
48 97 65

2.字符的本质
思考:sizeof(char) 和sizeof(‘a‘)
1)字符的本质为一个int类型的ascii码
2)字符变量保存的是ascii码,但是ascii码只需要一个字节即可保存
3.使用字符判断函数
isdigit 数字字符
isalpha 字母(大小写)
isalnum 数字字符和字母
islower 小写字母
isupper 大写字母
isspace 空格字符
0 --表示测试不成立
1 --表示测试成立

练习:
1.用户输入一个字符串,统计其中数字,字母,空格的个数
2.分别统计出大小写字母的个数

4.使用字符转换函数
tolower 大写转换为小写
int tolower(int c)
toupper 小写转换为大写
int toupper(int c)
练习:
1.将用户输入的字符串中的大写字母转换为小写字母
2.将用户输入的字符串中的数字 小写字母全部转换为*号
3.将用户输入的字符串中的其他字符转换为?号
其他字符不包括数字,字母,空格
Hell+ world
Hell? world
=================================
字符串
char s1[100] = "hello world";
char *s2 = "hello world";

0.字符串
不以字符数组引用时为一个常量
//栈
char str[] = "hello";
char str[12] = {‘h‘, ‘e‘,‘l‘,‘l‘, ‘o‘,‘\0‘};
char str[100];
//只读数据段
char *p = "hello world";

printf("%s", str); string
scanf("%s"); 不包含空格的输入
scanf("%[^\n]"); 包含空格的输入
printf("hello world");
char str[] = "hello world"
char str[] = {‘h‘,‘e‘,‘l‘,‘o‘,‘\0‘};
1.字符串的本质
1)字符串本质为字符串常量
"hello world"
2.思考:sizeof(‘A‘)和sizeof("A")
字符常量按照4个字节处理
字符串常量为了节省内存空间,字符串中的所有字符均以char类型处理
3.回忆char *str和char str[]区别
NSString NSMutableString
=================================
字符串的输入输出
1.字符串的输入和输出
0)字符串输入输出函数
1>回忆scanf获取字符串
scanf("%s");
2>如何获取带空格的字符串
%[^\n]
3>puts string
4>字符串输出
puts函数会在字符串输出后添加换行符号
printf("%s\n", str);
1)字符串的输入与溢出问题
思考:字符数组在输入时候的长度问题
2)解决方法
fgets
用法:fgets(buf, 100, stdin);
从标准输入获取指定长度的字符串,包含字符串结束符
=================================
字符串转换函数 100 + 200
需求:现在用户输入一个算术表达式,要求得到对应的结果
思考:如何将字符串中的字符数字转换为真实的数字
1.字符串转换函数
1)atol和atoi和atof函数
atof返回double

2)实现atoi函数(支持正负数)
示例:实现个位数的负数转换
练习:实现n位数的的正负数转换

3)strtol函数 1010 0x123456
字符串中不能出现和当前进制相悖的数据
1>atoi的增强版 2, 8, 10, 16
2>函数说明:将指定字符串按照base的进制方式转换为10进制
base范围为2~36

====================================
字符串常用函数
需求:用户需要知道输入的字符数的长度
1.字符串长度计算函数
1)strlen函数使用
"hello world"
while (str[i] != ‘\0‘)
{
cnt++;
i++;
}
2)思考:strlen和sizeof的区别
3)思考:strlen长度的大小

需求:用户需要我们在软件中实现选中字符的复制功能
2.字符串拷贝函数
strcpy 会将src内的所有内容拷贝到
dst数组中,包括\0
strncpy
思考:strncpy拷贝后是否会包含结束符
练习:实现一个字符串拷贝模块

需求:用户需要在软件中实现一个字符串的查找功能
3.单个字符的查找
strchr 查找字符第一次出现的地址
strrchr 查找字符最后一次出现的地址
练习:
输入一个字符串,再输入一个字符
查找并打印第一次出现和最后一次出现的字符
并输出该字符的地址

4.字符串查找到
strstr,strcasestr,strnstr
需求:用户需要输入一个名字,判断该用户是否存在

5.字符串比较函数
strcmp,strcasecmp
strncmp,strncasecmp
int strncmp(const char *s1, const char *s2, int n);
1)比较顺序:s1是否和s2相同
2)比较结果:0为相同,非0为不同,并且返回对应的差值
思考:非0的结果表示什么
3)思考:当s1比s2长度长的话会如何
返回s1最后一个字符和s2结束符的差
练习:
0.编写一个模拟登陆程序,输入用户名和密码,判断用户名和密码
是否和所设定的一致
1.编写一个验证程序,判断用户输入的字符串是否以qianfeng开头

需求:用户现在需要将输入的两个字符串组合成一个完整的字符串
6.字符串连接
strcat,strncat
练习:先输入自己的姓,再输入名字,最后将连接好的名字输出

需求:用户现在需要按照一定的格式分割一个字符串
7.字符串分割函数
1)strtok使用
1>要分割的内容
2>分割符,分割标记
2)如何获取下一个字符串
3)注意
0>不能截取字符串常量
1>截取后的长度
2>如果在下一次截取前截取另外一个字符串会如何
练习:
1.顺序输出分割后的所有字符串
2.查找字符串中的最长单词,并且输出该单词

需求:现在用户需要实现一个文本的查找替换功能
8.单个字符替换
strchr
9.字符串替换
strstr和strncpy联合实现

hello world

=====================================
常用字符串处理函数的实现
1.字符处理函数的实现
2.字符串处理函数的实现
strlen
int mystrlen(const char *str);

strcpy
void mystrcpy(char *dst, const char *src);

strchr
char *mystrchr(char *str, int c);

strrchr
char *mystrrchr(char *str, int c);

strcmp
int mystrcmp(const char *s1, const char *s2)

strcat
void mystrcat(char *s1, const char *s2);

====================================
“11:59:59”
sprintf和sscanf
%[^‘|‘]
需求:用户需要将每个用户的信息按照以下格式输出
1.字符串格式化函数
1)sprintf使用
2)printf和sprintf对比
int sprintf(const char *s, const char *fmt, …)
练习:
1.按照以下格式输出时间
年-月-日 时:分:秒
需求:用户需要将刚才的用户信息重新解析为单个的属性
2.字符串格式化读取函数

1)sscanf使用
集strtok和atoi等函数于一体
2)scanf和sscanf对比
====================================

超大数相加 “123” + “123” = “246” 2 = ’2‘
“123423413412374891374238476123846183474183”
“123423413412374891374238476123846183474183”

 

代码练习:  

 

1、strcmp.c

2014.3.4-C语言学习小结
#include <stdio.h>
#include <string.h>

int main(int argc, char *argv[])
{
    char *s1 = "HELLO";
    char *s2 = "hello";
    char s3[] = "hello";
    //返回值为三种情况
    //== 0 相等
    // > 0 s1 比s2 大
    // < 0 s1 比s2 小
    int ret = strcmp(s1, s2); //string compare
    printf("ret = %d\n", ret);

    //忽略大小写比较
    ret = strcasecmp(s1, s2);
    printf("ret = %d\n", ret);

    ret = strncmp(s2 + 1, s3 + 1, 2);//之比较指定个字符的内容是否相等
    printf("ret = %d\n", ret);

    ret = strncasecmp(s2, s3, 2);
    printf("ret = %d\n", ret);

    //s1 == s2 //比较2个指针是否相等
    //s1 == s3

    printf("s1 = %p\n", s1);
    printf("s2 = %p\n", s2);
    printf("s3 = %p\n", s3);


    return 0;
}
2014.3.4-C语言学习小结

 

 

2、strcat.c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <stdio.h>
#include <string.h>
 
int main(int argc, char *argv[])
{
    char s1[20] = "hello";
    char s2[] = "world";
 
    strcat(s1, s2);
 
    puts(s1);
 
    return 0;
}

  

 

3、strtok.c

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
#include <stdio.h>
#include <string.h>
 
int main(int argc, char *argv[])
{
    char str[] = "good,good+study-day*day/up";
    int len = strlen(str);
 
    char *res = strtok(str, ",+-*/");
 
    //循环结束 strtok == NULL
    while (res != NULL)
    {
        printf("res = %s\n", res);
        //循环增量
        //接着上一次的结果继续向后分割
        res = strtok(NULL, "-,*/+");
    }
 
 
    int i = 0;
    for (i = 0; i < len; ++i)
    {
        if (str[i] == ‘\0‘)
        {
            printf("|");
        }
        else
        {
            printf("%c", str[i]);
        }
    }
    printf("\n");
    return 0;
}

  

4、string.c

 

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
#include <stdio.h>
int mystrlen(const char *str);
int mystrlen_p(const char *str);
 
void mystrcpy(char *dst, const char *src);
void mystrcpy_p(char *dst, const char *src);
 
char *mystrchr(char *str, int c);
char *mystrrchr(char *str, int c);
 
int main(int argc, char *argv[])
{
    char *s = "hello world";
    int len = mystrlen_p(s);
    printf("len = %d\n", len);
 
    len = mystrlen(s);
    printf("len = %d\n", len);
 
    char *src = "hello";
    char dst1[10];
    char dst2[10];
 
    mystrcpy(dst1, src);
    puts(dst1);
    mystrcpy_p(dst2, src);
    puts(dst2);
 
    char *str2 = "hello";
    char key = ‘l‘;
 
    char *res = mystrchr(str2, key);
    int index = res - str2;
    printf("index = %d\n", index);
     
 
    return 0;
}
char *mystrrchr(char *str, int c)
{
    char *ret = NULL;
    while (*str != ‘\0‘)
    {
        if (*str == c)
        {
            ret = str;
        }
        str++;
    }
    return ret;
}
 
char *mystrchr(char *str, int c)
{
    while (*str != ‘\0‘)
    {
        if (*str == c)
        {
            return str;
        }
        str++;
    }
    return NULL;
}
 
void mystrcpy(char *dst, const char *src)
{
    int i = 0;
    while (src[i] != ‘\0‘)
    {
        dst[i] = src[i];
        i++;   
    }
    dst[i] = ‘\0‘;
}
 
void mystrcpy_p(char *dst, const char *src)
{
    while ((*dst++ = *src++) != ‘\0‘)
        ;
 
#if 0
    while (*src != ‘\0‘)
    {
        *dst++ = *src++;
        //dst++;
        //src++;
    }
    *dst = ‘\0‘;
#endif
}
 
int mystrlen_p(const char *str)
{
    int cnt = 0;
    while (*str != ‘\0‘)
    {
        str++;
        cnt++;
    }
    return cnt;
}
 
int mystrlen(const char *str)
{
    int i = 0;
    while (str[i] != ‘\0‘)
    {
        i++;
    }
    return i;
}

  

5、sscanf.c

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
#include <stdio.h>
 
int main(int argc, char *argv[])
{
    char *str = "11:59:59";
    int hour = 0;
    int min = 0;
    int sec = 0;
    sscanf(str, "%d:%d:%d", &hour, &min, &sec);
 
    sec += 1;
    if (sec >= 60)
    {
        sec = 0;
        min += 1;
        if (min >= 60)
        {
            min = 0;
            hour += 1;
            if (hour >= 24)
            {
                hour = 0;
            }
        }
    }
    char time[20] = {0};
    sprintf(time, "%d:%02d:%02d", hour, min, sec);
 
    puts(time);
    return 0;
}

  

2014.3.4-C语言学习小结,布布扣,bubuko.com

2014.3.4-C语言学习小结

上一篇:C++中的指针与引用


下一篇:spring多数据源的配置(转)