黑马程序员——C语言（函数、数组、字符串、进制、内存分析）总结

最新推荐文章于 2024-08-14 07:21:13 发布

darewolf

最新推荐文章于 2024-08-14 07:21:13 发布

阅读量660

点赞数

分类专栏：学习日记文章标签： c语言函数内存分析

本文链接：https://blog.csdn.net/u011117662/article/details/45296519

版权

学习日记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

C语言（函数、进制、内存分析、数组、字符串）总结

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

1 函数

1.1 什么是函数

任何一个C语言程序都是由一个或者多个程序段（小程序）构成的，每个程序段都有自己的功能，我们一般称这些程序段为“函数”。所以，你可以说C语言程序是由函数构成的。

比如你用C语言编写了一个MP3播放器程序，那么它的程序结构如下图所示：

1.2 函数的定义

1.2.1 定义函数的目的

将一个常用的功能封装起来，方便以后调用

1.2.2 定义函数的步骤

函数名：函数叫什么名字

函数体：函数是干啥的，里面包含了什么代码

1.3 格式

固定格式（很多语言的函数都是这么写的）

返回值类型函数名(形式参数列表)

{

函数体

}

举例

定义一个函数，计算两个整数的和

sum(int a, int b)

{

intc = a + b;

}

1.4 函数调用

sum(10, 11); 引出返回值

return的作用

1> 退出函数

2> 返回一个具体值给函数调用者

1.5 函数的参数

1.5.1 形参和实参的基本概念

形参就是在声明和定义函数时，定义的函数参数，实参就是在调用函数时传给函数的参数。

1>形参个数和实参的个数和类型必须一致：sum(10, 11, 12)

2>参数的传递是值传递

3>参数名不能跟函数内的局部变量同名

4>函数可以没有参数，也可以有无限多个参数

1.6 函数的返回值

1.6.1 return的作用

1> 退出函数

2> 返回一个具体值给函数调用者

1.6.2 返回值注意点

1> void代表没有返回值

2> 如果没有明确说明返回值类型，默认是返回int类型

3> 就算明确声明了返回值类型，也可以不返回任何值

4> void可以省略return

5> 可以多次使用return

6> return后面不能有其他语句

1.7 函数的弱语法

如果没有写返回值类型，默认是int

如果写了返回值，可以不返回

调用一个没有定义过的函数

1.8 函数注意

1> 默认情况下，不允许有函数的名称一样

2> 函数不能嵌套定义

3> 函数不能重复定义，但是可以重复声明

4> 如果有函数的声明，没有函数的定义

编译可以通过，因为编译器只会检测语法合不合理，并不会检测函数有没有定义

链接报错，因为链接的时候会检测函数是否定义

1.9 函数的补充

1> main函数

返回值：0，正常退出；1，异常退出

2> printf函数

#include

返回值：字符串的长度

1.10 .h文件和.c文件的分工

1.10.1 单文件的坏处

一个文件的内容太多，不利于阅读、调试

多人修改同一个文件出问题

公司里面是团队合作

1.10.2 将sum函数抽取到另一个.c文件中

先直接调用sum函数，编译警告、链接main.c错误

#include “sum.c” ，编译链接main.c，运行成功（画图分析.o文件中的东西）

如果avr.c中使用sum.c，编译链接main.c，运行程序（画图分析出错原因）

1.10.3 在其他文件中声明sum函数

int sum(int,int);

编译链接main.c

编译链接sum.c

编译链接main.c sum.c，运行成功

avr.c利用一样的方法

1.10.4 不抽取声明的坏处：增加新的函数了

抽取到.c文件中？开发工具会将所有的.c进行编译链接

抽取到.h文件中

1.10.5 抽取步骤总结

.c文件写函数的定义

.h文件写函数的声明

要想用我的函数，请包含我的.h文件

1.11 #include

1> 作用：拷贝右边文件的所有内容到#include所在的位置

2> 自定义的文件用""，系统自带的文件用<>

3> #include <stdio.h>的目的：拷贝printf函数的声明

2 进制、内存分析

2.1 类型说明符

2.1.1 short和long

不同类型所占用的存储空间

1> short和long可以提供不同长度的整型数，也就是可以改变整型数的取值范围。在64bit编译器环境下，int占用4个字节（32bit），取值范围是-2³¹~2³¹-1；short占用2个字节（16bit），取值范围是-2¹⁵~2¹⁵-1；long占用 8个字节（64bit），取值范围是-2⁶³~2⁶³-1

2> 总结一下：在64位编译器环境下，short占2个字节(16位)，int占4个字节(32位)，long占8个字节(64位)。因此，如果使用的整数不是很大的话，可以使用short代替int，这样的话，更节省内存开销。

3> 世界上的编译器林林总总，不同编译器环境下，int、short、long的取值范围和占用的长度又是不一样的。比如在16bit编译器环境下，long只占用4个字节。不过幸运的是，ANSI \ ISO制定了以下规则：

short跟int至少为16位(2字节)

long至少为32位(4字节)

short的长度不能大于int，int的长度不能大于long

char一定为为8位(1字节)，毕竟char是我们编程能用的最小数据类型

4> 可以连续使用2个long，也就是long long。一般来说，longlong的范围是不小于long的，比如在32bit编译器环境下，long long占用8个字节，long占用4个字节。不过在64bit编译器环境下，long long跟long是一样的，都占用8个字节。

5> 还有一点要明确的是：short int等价于short，long int等价于long，long longint等价于long long

2.1.2 signed和unsigned

1> 首先要明确的：signed int等价于signed，unsigned int等价于unsigned

2> signed和unsigned的区别就是它们的最高位是否要当做符号位，并不会像short和long那样改变数据的长度，即所占的字节数。

signed：表示有符号，也就是说最高位要当做符号位，所以包括正数、负数和0。其实int的最高位本来就是符号位，已经包括了正负数和0了，因此signed和int是一样的，signed等价于signed int，也等价于int。signed的取值范围是-2³¹ ~ 2³¹- 1

unsigned：表示无符号，也就是说最高位并不当做符号位，所以不包括负数。在64bit编译器环境下面，int占用4个字节（32bit），因此unsigned的取值范围是：0000 0000 0000 0000 0000 00000000 0000 ~ 1111 1111 1111 1111 1111 1111 1111 1111，也就是0 ~ 2³² - 1

2.2 char类型

2.2.1存储细节

ASCII单字节表（双字节GBK\GB2312\GB18030\Unicode）

2.2.2 常见错误

char c = A;

char c = "A";

char c = 'ABCD';

char c = '男';

2.2.3 当做整型使用

在-128~127范围内，可以当做整数来用

2%c和%d\%i的使用

printf(“%d”, ‘A’);

printf(“%c”, 68);

2.3 转义字符

转义字符	意义	ASCII码值
\n	将当前位置移到下一行开头（回车换行）	10
\t	跳到下一个TAB位置	9
\\	代表一个反斜线字符	92
\'	代表一个单引号字符	39
\"	代表一个双引号字符	34
\0	空字符	0

3 数组、字符串

3.1 数组的基本概念

一个int类型的变量能保存一个人的年龄，如果想保存整个班的年龄呢？

3.1.1 什么是数组

数组，从字面上看，就是一组数据的意思，没错，数组就是用来存储一组数据的

3.1.2 数组的特点

只能存放一种类型的数据，比如int类型的数组、float类型的数组

里面存放的数据称为“元素”

3.2 数组的定义

3.2.1 定义

声明数组的类型

声明数组的元素个数（需要多少存储空间）

3.2.2格式

元素类型数组名[元素个数];

比如：int ages[3];

3.2.3 简单使用

简单初始化：intages[5] = {19, 19, 20, 21, 25};

元素有顺序之分，每个元素都有一个唯一的下标（索引），从0开始

数组元素的访问：a[i]

3.2.4 初始化

初始化方式

int a[3] = {10, 9, 6};

int a[3] = {10,9};

int a[] = {11, 7, 6};

int a[4] = {[1]=11,[0] = 7};

3.2.5 常见错误

int a[];

int[4] a;

int a[b];

a = {10, 11};

a[4] = {10,9,8,5};

3.2.6 内存分析

数组存储空间的大小

存储空间的划分（内存的分配是从高地址到低地址进行的，但一个数组内部元素又是从低到高进行的）

数组名的作用，查看元素地址

数组越界的注意

3.2.7 其他使用

数组与函数参数

数组元素作为函数参数

数组作为函数参数（sizeof注意）

遍历数组元素

两种方式遍历（while循环和for循环）

遍历元素值和元素地址

字符数组的使用

3.3 二维数组

3.3.1 什么是二维数组

一个数组能表示一个班人的年龄，如果想表示很多班呢？

什么是二维数组？intages[3][10]; 三个班，每个班10个人

相当于3行10列

相当于装着3个一维数组

二维数组是一个特殊的一维数组：它的元素是一维数组。例如int a[2][3]可以看作由一维数组a[0]和一维数组a[1]组成，这两个一维数组都包含了3个int类型的元素

3.3.2 存储

存储大小

存储结构和顺序

存储地址问题

3.3.3 初始化

int a[3][4] = {1,2,3,4,5,6};

int a[3][4] = {{},{},{}};

数组元素简单访问

int a[][5] = {3,21,31,2,32,1};

注意错误：

int a[3][4];

a[3] = {};

3.3.4 遍历

遍历所有的元素

遍历地址

使用场合：五子棋、俄罗斯方块

3.4 字符串

3.4.1 什么是字符串

简单的字符串”itcast”

一个’i’是一个字符

很多个字符组合在一起就是字符串了

3.4.2 字符串的初始化

char a[] = “123”; 和 char a [] ={‘1’,’2’,’3’};的区别，可以比较大小

“123”其实是由’1’、’2’、’3’、’\0’组成

“123”的存储分布

字符串的输出”%s”，’\0’是不会输出的

3.4.3 \0的作用

输出char a[] ={‘o’,’k’};

在char a[]前面搞个”mj”

输出”mj”

再输出a

char a[] = {‘i’,’t’,’\0’,’c’};

3.4.4 常用字符串处理函数

strlen函数：计算字符串长度

1.计算的是字符数，并不是字数。一个汉字算作3个字符

2.计算的字符不包括\0

3.从某个地址开始数字符的个数，直到遇到\0为止

3.5 字符串数组

3.5.1 使用场合

* 一维字符数组中存放一个字符串，比如一个名字charname[20] = "mj"

* 如果要存储多个字符串，比如一个班所有学生的名字，则需要二维字符数组，char names[15][20]可以存放15个学生的姓名(假设姓名不超过20字符)

* 如果要存储两个班的学生姓名，那么可以用三维字符数组char names[2][15][20]

3.5.2 初始化

char names[2][10] = { {'J','a','y','\0'}, {'J','i','m','\0'} };

char names2[2][10] = { {"Jay"},{"Jim"}};

char names3[2][10] = { "Jay","Jim" };

4 代码示例

#include <stdio.h>

// 数组作为函数参数，可以省略元素个数
// 数组作为函数参数，传递是整个数组的地址，修改函数形参数组元素的值，会影响到外面的实参数组

void change(int array[])
{
    //printf("array==%p\n", array);
    
    array[0] = 100;
}

void change2(int n)
{
    n = 100;
}

int main()
{
    int ages[6] = {10, 11, 10, 11, 10, 11};
    
    //printf("ages==%p\n", ages);
    
    change(ages);
    
    //change2(ages[0]);
    
    printf("%d\n", ages[0]);
    return 0;
}

/*

设计一个函数，找出整型数组元素的最大值
*/

#include <stdio.h>

int maxOfArray(int array[], int length)
{
    // 数组当做函数参数传递时，会当做指针变量来使用，指针变量在64bit编译器环境下，占据8个字节
    
    //int size = sizeof(array);
    //printf("array=%d\n", size);
    
    //sizeof(array);
    
    // 1.定义一个变量存储最大值(默认就是首元素)
    int max = array[0];
    
    // 2.遍历所有元素，找出最大值
    for (int i = 1; i<length; i++)
    {
        // 如果当前元素大于max，就用当前元素覆盖max
        if (array[i] > max)
        {
            max = array[i];
        }
    }
    
    return max;
}

int main()
{
    int ages[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    int ages2[] = {11, 90, 67, 150, 78, 60, 70, 89, 100};
    
    //int size = sizeof(ages);
    
    //printf("ages=%d\n", size);
    int max = maxOfArray(ages, sizeof(ages)/sizeof(int));
    
    printf("%d\n", max);
    return 0;
}

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------