C语言笔记第十三天

字符串节取例子

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>

int main()
{
	char mag[1024] = "[12:13.45][23:34.54]总有一天你哭过的事会笑着说出来";

	int m = 0, m2 = 0, s = 0, s2 = 0;
	char lyric[1024] = "";

	sscanf(mag, "%*c%d%*c%d%*5s%d%*c%d%*4s%s", &m, &m2, &s, &s2, lyric);

	printf("%d:%d - %d:%d  %s\n", m, s, m2, s2, lyric);

	return 0;
}

C语言的const就不说了,一个跑龙套的角色实在没啥意义说

const int a = 10; 是一个伪常量,可读不能直接写

*(int *)&a = 100; 就可以修改了

其实就是const int*(指向的值不可修改,指向可以修改) 被我们强转成了int*

int* const a 指向不可以修改值可以

const int* const a 指向和值都不可以修改

typedef

#include <stdio.h>

//普通类型
typedef INT32;
INT32 num = 10;

//数组类型
typedef int INTARR[5];
INTARR int_arr= { 1,2,3,4,5 };

//结构体类型
//struct Student
//{
//	char name[1024];
//	int age;
//};
//typedef struct Student STRUCT;

//也可以
typedef struct Student
{
	char name[1024];
	int age;
}STRUCT;

STRUCT s = { "aaa",111 };

//函数指针
typedef int (*FUNC)(int, int);
int add(int num, int num2)
{
	return num + num2;
}
FUNC func = add;

int main()
{
	printf("%d\n", num);	//10

	for (int i = 0; i < 5; i++)
	{
		printf("%d ", int_arr[i]);	//1 2 3 4 5
	}
	printf("\n");

	printf("name:%s age:%d\n", s.name, s.age);	//name:aaa age:111

	printf("%d\n", func(1, 2));	//3

	return 0;
}

结构体

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>

//定义结构体类型不要对其初始化,因为定义类型时并不会分配空间
//在定义结构体变量时才会分配空间
//这个其实可以叫声明结构体

struct Student
{
	char name[1024];
	int age;
};

struct Student2
{
	char name[1024];
	int age;
}s2;

struct 
{
	char name[1024];
	int age;
}s3;


int main()
{
	//定义结构体变量
	struct Student s;
	s.age = 111;

	//s.name = "aaa";	//有没有对这个报错好奇的
	//name可以理解成指针常量(char * const name)
	//"aaa" 是一个字符常量 赋值过去的是首地址
	//一个常量赋值给另一个常量明显不靠谱
	//同样char* str = "aaa" 它只是把字符常量的首地址 赋值 给了str
	//其是这个问题不在于数组名是啥东西,理解 = (它叫做赋值就可以)
	//它不是数学上的一个苹果 = 一块钱 两个苹果 = 2块钱 而是苹果就是一块钱

	s.name[0] = 'a';
	s.name[1] = 'a';
	s.name[2] = 'a';
	s.name[2] = '\0';

	//这样就可以,因为s.name[0]是一个变量

	printf("name:%s\nage:%d\n", s.name, s.age);	//aaa 1111

	//这个叫做 拷贝 这不是废话 他是一个字节一个字节的 赋值
	strcpy(s.name, "bbb");

	printf("name:%s\nage:%d\n", s.name, s.age);	//bbb 111

	return 0;
}

结构体操作

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

struct Student
{
	char name[1024];
	int age;
};

//初始化
int main1()
{
	struct Student s = { "aaa",111 };

	printf("name:%s\nage:%d\n", s.name, s.age);	//aaa 1111

	return 0;
}

//输入
int main2()
{
	struct Student s;
	memset(&s, 0, sizeof(s));	//清空结构体

	printf("enter name:");
	scanf("%s", s.name);

	printf("enter age:");
	scanf("%d", &s.age);

	printf("name:%s\nage:%d\n", s.name, s.age);	

	return 0;
}

//赋值
int main()
{
	struct Student s = { "aaa",111 };
	struct Student s2;

	s2 = s;

	printf("name:%s\nage:%d\n", s2.name, s2.age);	//aaa 1111

	return 0;
}

结构体数组

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>

struct Student
{
	char name[1024];
	int age;
};

int main1()
{
	struct Student s[3] =
	{
		{"aaa",111},
		{"bbb",222},
		{"ccc",333}
	};

	//遍历
	for (int i = 0; i < 3; ++i)
	{
		printf("name:%s\nage:%d\n", s[i].name, s[i].age);
		printf("\n");
	}

	return 0;
}

int main()
{
	struct Student s[3];

	//输入
	for (int i = 0; i < 3; ++i)
	{
		printf("enter name:");
		scanf("%s", s[i].name);
		printf("enter age:");
		scanf("%d", &s[i].age);
	}

	//遍历
	for (int i = 0; i < 3; ++i)
	{
		printf("name:%s\nage:%d\n", s[i].name, s[i].age);
		printf("\n");
	}

	return 0;
}

结构体指针

#define _CRT_SECURE_NO_WARNINGS

#include <stdio.h>
#include <string.h>

struct Student
{
	char name[1024];
	int age;
};

int main()
{
	struct Student s = { "aaa",111 };

	//其实和正常类型一样 *p 就是 s , p 就是 &s
	struct Student* p = &s;

	printf("name:%s,age:%d\n", s.name, s.age);	//aaa 111
	printf("name:%s,age:%d\n", p->name, p->age);	//aaa 111
	printf("name:%s,age:%d\n", (*p).name, (*p).age);	//aaa 111

	return 0;
}

结构体做函数参数

#include <stdio.h>

//结构体传参时一般传指针,可以节省开销

typedef struct Student
{
	char name[1024];
	int age;
	int num;
	int num2;
	int num3;
	int num4;
}Student;

void func(Student s);

void func2(Student* s);

int main()
{
	Student s = { "aaa",1,2,3,4,5 };

	func(s);

	func2(&s);

	return 0;
}

void func(Student s)
{
	printf("%d\n", sizeof(s));	//1040
	printf("name = %s,age = %d,num = %d,num2 = %d,num3 = %d,num4 = %d\n", s.name, s.age, s.num, s.num2, s.num3, s.num4);
}

void func2(Student* s)
{
	printf("%d\n", sizeof(s));	//4
	printf("name = %s,age = %d,num = %d,num2 = %d,num3 = %d,num4 = %d\n", s->name, s->age, s->num, s->num2, s->num3, s->num4);
}

结构体内存对齐

32位下正常寻址是4字节(64位应该是8,其实就是字节数嘛.但是这个我不清楚啊),内存对齐是为了高效的寻址,也就是牺牲空间换时间

每一个成员最大占成员中最大的基础类型(字节)

每一次偏移当前成员的基础类型(字节)(结构体嵌套结构体时嵌套的结构体对齐的空间不能继续利用)

最后总字节数是成员中最大的基础类型的整数倍

大致就这样了,明天结构体还差一点,然后共用体枚举.

在来个链表,文件读写.然后C语言也就完事了.

没想到的是居然比预期长了一倍.