发表于 分类于
本文字数： 1.8k 阅读时长 ≈ 2 分钟

C语言基础学习笔记（11）：指针与数组的关系

图： 北英格兰，惠特比港（Whitby Harbour）

Guderian出品

指针与一维数组的关系

一维数组在内存中是线性排列的。假设存在一个任意的int类型数组a[N]，数组名a代表了数组的首地址&a[0]，则&a[i]等价于(a+i)。注意这里a+1不是加上1个字节，而是取决于a的基类型（这里是int，即为4个字节）：a+1等价于a+sizeof(基类型)。因此我们可以得出一维数组元素的等价引用形式：a[i]等价于*(a+i)。下面举两个例子：

示例一

用指针读入一维数组并用指针输出一维数组：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>

int main()
{
	int a[10], i, *p = NULL;
	p = a;
	
	for (i=0; i<10; i++)
		scanf("%d", &p[i]);
	
	p = a;
	for (i=0; i<10; i++)
		printf("%d", p[i]);
	printf("\n");
	
	return 0;
}

示例二

示例一的另一种实现方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <stdio.h>

int main()
{
	int a[10], *p = NULL;
	
	for (p=a; p<a+10; p++)
		scanf("%d", p);
	
	for (p=a; p<a+10; p++)
		printf("%d", *p);
	printf("\n");
	
	return 0;
}
阅读全文 »

发表于 更新于 分类于
本文字数： 2.3k 阅读时长 ≈ 2 分钟

C语言基础学习笔记（10）：字符串

图： 第一张黑洞照片（The first image of a black hole published in April 2019）

​ by 事件视野望远镜（Event Horizon Telescope）

Guderian出品

  1. C语言中没有专门的字符串数据类型。在定义字符串，字符数组的长度应比字符串长度多1，给\0留个位置：

    1
    2
    #define STR_LEN 80
    char str[STR_LEN+1];

  2. C语言常用字符串处理操作函数：#include <string.h>

    （1）strlen(s);返回字符串s的长度

    （2）strcpy(s1,s2);复制s2至s1，返回s1的指针

    （3）strcat(s1,s2);复制s2接在s1末尾，返回s1的指针

    （4）strcmp(s1,s2);比较s2和s1的大小，返回0表示相等，返回值大于零表示s1比s2大，返回值小于零表示s1比s2小。（比较规则：当出现第一对不相等的字符时，由这两个字符决定所在字符串的大小，返回其ASCII码比较的差值。）

    （5）strncpy(s1,s2,n);复制s2前面最多n个元素至s1中，比strcpy()更安全

    （6）strncat(s1,s2,n);复制s2前面最多n个元素至s1末尾，比strcat()更安全

    （7）strncmp(s1,s2,n);比较s2和s1前面最多n个元素的大小

  3. 向函数传递字符串的两种方法：

    （1）用字符数组作函数参数

    （2）用字符指针作函数参数

  4. 用字符数组作函数参数示例：计算实际字符个数

    1
    2
    3
    4
    5
    6
    7
    8
    unsigned int MyStrlen(const char str[]) //防止原字符数组被修改
    {
        int i;
        unsigned int len = 0;
        for (i=0; str[i]!='\0'; i++)
            len++;
        return len;
    }

  5. 用字符指针作函数参数示例：计算实际字符个数

    1
    2
    3
    4
    5
    6
    7
    unsigned int MyStrlen(const har *pstr) //防止原字符数组被修改
    {
    	unsigned int len = 0;
    	for (; *pstr!='\0'; pstr++)
            len++;
        return len;
    }

  6. 用字符指针作函数参数示例：计算实际字符个数（Optimized versoin）

    1
    2
    3
    4
    5
    6
    7
    unsigned int MyStrlen(const char *pstr) //防止原字符数组被修改
    {
        const char *start = pstr;
        while (*pstr)
            pstr++;
        return pstr-start;
    }

  7. 用字符数组作函数参数示例：复制字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void MyStrcpy(char dst[], char src[])
    {
        int i = 0;
        while (src[i]!='\0')
        {
            dst[i] = src[i];
            i++;
        }
        dst[i] = '\0';
    }

  8. 用字符指针作函数参数示例：复制字符串

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    void MyStrcpy(char *dst, char *src)
    {
        while (*src!='\0')
        {
            *dst = *src;
            src++;
            dst++
        }
        *dst = '\0';
    }

  9. 用字符指针作函数参数示例：复制字符串（Insane versoin!!!）

    1
    2
    3
    4
    void MyStrcpy(char *dst, const char *src)
    {
        while (*dst++ = *src++);	//空字符被赋值之后循环才结束
    }

  10. 不要写没人能看懂的代码！第6点、第9点和第12点的代码风格仅供欣赏！DO NOT TRY IT AT HOME!

    阅读全文 »

发表于 分类于
本文字数： 1.2k 阅读时长 ≈ 1 分钟

C语言基础学习笔记（9）：指针

图：土星光环

Guderian出品

请把本文与本文与一篇上古时期的佛经C++的指针变量进行对比参考🕮

  1. int *a和*a有着巨大的差别：int *a是定义一个指向int类型数据的指针a；*a是对指针a解引用（Pointer Dereference），*a*即为指针a所指向的内存地址上存储的数据。如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    #include <stdio.h>
    int main()
    {
    	int a = 0, b = 1;
    	int *pa, *pb;	
    	//不能写成int* pa, pb，这样只表示pa是一个指针变量，pb是一个整型变量
    	pa = &a;
    	pb = &b;
    	printf("a=%d, b=%d\n", a, b);
    	printf("*pa=%d, *pb=%d\n", *pa, *pb);
    	return 0;
    }

    输出结果为：

    1
    2
    a=0, b=1
    *pa=0, *pb=1

  2. C语言中，只要pa指向a,*pa就是a的别名。

  3. 指针变量的一大应用就是用作函数参数，这样做的好处就是可以再被调函数中改变实参的值。比如：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    #include <stdio.h>
    void Func(int *par);
    int main()
    {
    	int arg = 1;
    	printf("arg = %d\n", arg);
    	Func(&arg);
    	printf("arg = %d\n", arg);
    	return 0;
    }
    void Func(int *par)
    {
    	printf("par = %d\n", *par);
    	*par = 2;
    }

    输出结果为：

    1
    2
    3
    arg = 1
    par = 1
    arg = 2

  4. 函数指针（Function Pointer）：就是指向函数的指针变量

    数据类型 (*指针变量名)(形参列表)

  5. 函数指针示例：

    若有函数原型：int Func(int a, int b);

    则可定义函数指针int (*f)(int, int);

    令f = Func;就是让f指向函数Func()

    • 编译器将不带()的函数名解释为该函数的入口地址
    • 函数指针变量存储的是函数在内存中的入口地址

  6. 正确写法int (*f)(int, int);。常见错误：

    （1）忘了写前一个()：int *f(int, int);，等价于声明了一个函数名为f、返回值是整型指针类型的函数；

    （2）忘了写后一个()：int (*f);，等价于定义了一个整型指针变量

阅读全文 »

发表于 更新于 分类于
本文字数： 2.5k 阅读时长 ≈ 2 分钟

C语言实现选择、插入、冒泡排序算法

Guderian出品

准备工作

1
2
3
4
5
6
7
8
9
#include <stdio.h>

const int N = 10;

void swap(int *x, int *y);
void Sort(int arr[], void(*f)(int *));
void SelectionSort(int arr[]);
void InsertionSort(int arr[]);
void BubbleSort(int arr[]);

主函数

1
2
3
4
5
6
7
8
9
10
11
int main()
{
	int a[N] = {2,1,3,9,8,6,5,0,4,7};
	Sort(a, InsertionSort);	//此处选择排序算法
	
	for (int i = 0; i < N; i++)
		printf("%d ", a[i]);
	printf("\n");	
	
	return 0;
}

实现两数交换函数

1
2
3
4
5
6
void swap(int *x, int *y)
{
	int tmp = *x;
	*x = *y;
	*y = tmp;
}

实现选择排序函数

1
2
3
4
5
6
7
8
9
10
11
void SelectionSort(int arr[])
{
	for (int i = 0; i < N-1; i++)
	{
		int min = i;
		for (int j = i+1; j < N; j++)
			if (arr[j] < arr[min])
				min = j;
		swap(&arr[i], &arr[min]);
	}
}
阅读全文 »

发表于 更新于 分类于
本文字数： 678 阅读时长 ≈ 1 分钟

C和C++中memcpy()函数

Guderian出品

头文件

  • C： <string.h>
  • C++： <cstring>

声明

void *memcpy(void *str1, const void *str2, size_t n)

此处size_t变量类型等价于long unsigned int即无符号长整型，在32位机器上为32位，在64位机器为中64位。

注：32位机器指CPU通用寄存器的数据宽度为32位，也就是说CPU一次可以运行32bit数据

描述

从内存 str2 复制 n 个字符到内存 str1

参数

  • str1 ——指向存储复制内容的目标数组。
  • str2 ——指向复制目标数组。
  • n——要被复制的字节数。

返回值

返回一个指向存储区str1的指针。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <string.h>
 
int main ()
{
	char s[50] = "the quick brown fox jumps over the lazy dog";
	char t[50];
 
	memcpy(t, s, sizeof(s));
	printf("%s\n", t);
   
	return(0);
}

输出结果：

1
the quick brown fox jumps over the lazy dog
阅读全文 »