阐述程设理论2

nymph181

已于 2024-01-10 23:21:44 修改

阅读量392

点赞数 11

文章标签：算法

于 2023-12-14 23:28:08 首次发布

本文链接：https://blog.csdn.net/SSL_hzb/article/details/135004601

版权

1.若用数组名作为函数调用的实参，则传递给形参的是（A）
A.数组首元素的地址
B.数组的第一个元素的值
C.数组中全部元素的值
D.数组元素的个数

实参(fun(1))，形参（fun(int a) ）

参数里面int p[]可以写成*p

2.以下叙述中，正确的是（A）
A.实参与其对应的形参各占独立的存储单元
B.实参与其对应的形参共占存储单元
C.只有当实参和与其对应的形参同名时，才共占存储单元
D.形参是虚拟的，不占用存储单元

‘\0’=0
输出NULL也是0？

int fun(char *x){
   char *y=x;
   while(*y++);
   return(y-x-1);//不懂为什么-1
}

int astr(char *s, char *t)
{
	while((*s)&&(*t)&&(*t++ == *s++));
	return (*s-*t);//这里是值相减，也就是比较两个字符串大小
}

字符串函数

strcat

strcat(str1,str2)//将str2连接到str1的后面，并且返回str1的首地址
int main() {
	char s1[20] = "abc", s2[] = "efg";
	strcat(s1, s2);
	printf("%s", s1);
	
	char s3[20] = "ccd", s4[] = "effff";
	printf("%s", strcat(s3 + 2, s4));//输出deffff，这里返回的是s3+2的地址，即从d开始输出

	char s5[20] = "I am ", s6[] = "shit";
	printf("%s", strcat(s5, s6, 2));
}

strncat

int main() {
	char s5[20] = "I am ", s6[] = "shit";
	printf("%s", strcat(s5, s6, 2);
	//这个函数比strcat多一个参数，代表即把s6的前多少为与s5连起来，这里就是链接前2个
	//输出I am sh
}

strcpy

int main(){
	char *p1,*p2,str[50]="ABCDEFG";
	p1="abcd";
	p2="efgh";
	strcpy(str+1,p2+1);//可以看成取str[0~1-1]，就是从1这里开始拼与p2[1~end]拼接起来
	//这一步后str为"Afgh"
	strcpy(str+3,p1+3);//从3这里开始拼
	//然后这一步后str为"Afgd"
	printf("%s",str);
}

strcpy(s1,s2);//从s1的首地址开始，把s2首地址后面的复制过来
比如strcpy(str + 1, str2 + 3)//见上面代码

strncpy
把前n个字符复制过去

strcmp
比较两个字符串的字典序大小

int main() {
	strcmp(str1, str2);
	//若str1的字典序大于str2的字典序，则返回大于0的整数
	//若str1的字典序等于str2的字典序，则返回0
	//若str1的字典序小于str2的字典序，则返回小于0的整数
	printf("%d", strcmp("abc", "edf"));//<0
}

strncmp
比较两个字符串前n个字符(组成的字符串)的字典序

strlwr
将字符串全部转化为小写

int main(){
	char c = 'A';
	strlwr(&c);
	printf("%c", c);
	
	char s1[] = "abCDefg";
	strlwr(s1);
	printf("%s", s1);
}

strupr
将字符串全部转化为大写

strchr(str, c)
返回str中找字符c第一次出现的位置的指针

char str[] = "abcdedcbaf";
printf("%d\n", strchr(str, 'd') - str);//'d'在str中第一次出现的下标
printf("%s\n", strchr(str, 'd'));//从第一次'd'出现开始的字符串

输出：
3
dedcbaf

strchr(str1, str2)
返回str1中查找str2第一次出现的位置的指针，用法可以参考上面代码

B.语句块 char *p = “hello” + 1; printf(“%s”, p); 输出结果是 ello
D.对于 char *p = “hello”; char *q = “hello”; ，p和q的值是一致的

（多选）下面关于指针的描述正确的是：（）
A.当使用free释放一个指针内容后，指针变量的值被置为null;
B.32位系统下任何类型指针的长度都是4个字节；
C.指针的数据类型声明的是指针实际指向内容的数据类型；
D.野指针是指向未分配或者已经释放的内存地址;

（多选）下列指针类型与描述相匹配的有：（）
A.int **p : 一个指向指针的指针；
B.int (*p)() ：一个指向函数的指针；
C.int p(char *a)：一个形参为指针的函数；
D.int *p(char *a)：一个形参与返回值均为指针的函数；

char s1[5]="abcd";
char s2[]="abcd";
char s3[] = {'a', 'b', 'c', 'd'};
char *s4 = "abcd";

这样子定义的都是什么呢，什么时候会有\0

定义：char (*p)[5]; 表示的含义是：A
A.定义了一个指向一维数组的指针p，所指向的一维数组具有5个char元素；

int (*fun)( )表示的含义是：
C.一个用于指向函数的指针变量；

定义：int *fun( );表示的含义是：
D.一个返回值为指针的函数名；

关于定义const int p的说法正确的是：B
A.p的指向不可以改变；
B.不能通过p去修改p指向的变量的值；
C.以上两者均不能改变；
D.以上两者均可以改变；

下面程序段的输出是：

static char *s[] = {"black", "white", "pink", "violet"};
char **ptr[] = {s+3, s+2, s+1, s}, ***p;
p = ptr;
++p;
printf("%s", **p+1);

int a[] = {2, 4, 6, 8, 10};
int *p = a;
*p++;
//是p++先，*和++运算级：++先
printf("%d ", *p);
(*p)++;
printf("%d ", *p);

输出4 5

假设 s 是字符数组，下面哪条语句与其他3条不等价？
A.*s = 0;
B.s[0] = ‘\0’;
C.strcpy(s, “”);
D.strcat(s, “”);

下面说法正确的是（ ACD）
A.32位系统下任何类型指针的长度都是4个字节；
B.当使用free释放一个指针内容后，指针变量的值被置为null;
C.int *p(char *a)表示一个形参与返回值均为指针的函数；
D.指针的数据类型声明的是指针实际指向内容的数据类型；

下列关于const char* p1，char const p2，const char const p3的说法中，正确的是：CD
A.p1不可以修改，可以通过p1修改变量
B.p2可以修改，不可以通过p2修改变量
C.p3不可以修改，也不可以通过*p3修改变量
D.p1可以指向不是常量的变量，p2可以指向常量

在32位平台上，变量p1, p2的声明如下：
int *p1[10];
int (*p2)[10];
A.p1是数组指针，p2是指针数组
B.p1是指针数组，p2是数组指针
C.p1占内存字节数为40，p2占内存字节数为4

已知函数int fun(int N), 函数指针 p, 及变量 x,y，则下列描述中正确的有：AD
A.p=fun;表示将指针p指向函数fun;
B.p=fun(x);表示将指针p指向函数fun;
C.y= *p(x); 表示调用指针p指向的函数；
D.y= (*p)(x); 表示调用指针p指向的函数；

一些传参：
void sortByLength(char *strArray[], int numStrings);

二维数组
#define COL 3
#define ROW 3
void matrixInput(int (*mat)[COL]);
void matrixPrint(int *mat[ROW]);
void matrixAddT(int *mat);

#include <stdio.h>

void testfun(int a, int b, int c) {
	printf("%d %d %d\n", a, b, c);//输出2 1 0
}

int main() {
	int a = 0;
	testfun(a++, a++, a++);//从右至左执行
}

作用域

{
	int b = 2;
	a = b;
}
a = b;//error，b只能在大括号内被访问到

What is extern & static?

static 是局部变量，离开函数还会存在（生命周期是整个应用）
！！！extern不会

局部变量：
①自动变量，即动态局部变量(离开函数，值就消失)。
②静态局部变量(离开函数，值仍保留)。
③寄存器变量(离开函数，值就消失)。
④形式参数可以定义为自动变量或寄存器变量。

全局变量：
①静态外部变量(只限本程序文件使用)。
②外部变量(即非静态的外部变量，允许其它程序文件引用)。
注：静态变量也可以全归于局部变量

如果对全部元素都赋初值(即提供全部初始数据)，则定义数组时对第1维的长度可以不指定，但第2维的长度不能省。

多维数组形参仅第一维用不定长数组表示，如 b[][3]

void matrix_add(int a[][3], int b[][3], size_t m);

32是空格
10是换行

char 1字节
int

tgmkb

char msg[3] = {‘H’ , ‘i’ , ‘!’ }; //不是字符串
char msg[4] = { ‘H’ , ‘i’ , ‘!’ , ‘\0’ };
char msg[4] = “Hi!” ;
char msg[ ] = “Hi!” ;
其中2)、 3)、 4)三种声明是等价的字符串。

在这里插入图片描述

指针

int main() {
	int *p = NULL;
	int a = 1;
	p = &a;
	*p = 2;//这里*p相当于a，修改了a为2
	printf("%d %d", p, a);
}


int main() {
	int *p = NULL;
	int a[] = {1, 2, 3, 5};
	p = a;
	printf("%d %d", *(a + 2), a[2]);
	//p[2]   ~   *(p + 2)
	//p + 2   ~  &p[2]
}

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

void fun(char *p) {
	printf("%c\n", *(p + 2));
}

void fun1(char p[]) {
	printf("%c\n", p[2]);
}

int main() {
	char a[] = "abcdef";
	char *pt = a;//a代表首地址
	char *pt2 = "114514";
	//int不行，char可以 ，那这样子定义会有\0吗 (不会
	
	//a++;
	pt++;
	putchar(*(pt + 2)); 
	//a不是指针所以++不了，很奇怪
	//pt是指针，然后pt[2]是*(pt + 2)，所以先++后，再调用*(pt + 2)输出的实际上是b 
	
	printf("%d\n", a);
	//printf("%c", *(a + 2));
	//我定义a[10]，其实相当于占用了10个地方，然后a是第0个值的指针，a[2]等价于*(a + 2) 
	//a等价于a[0]的地址，输出*a就是a[0]
	fun(a);
	fun1(pt);
	printf("%s", pt2);
}

基础

整型int所占字节数与数值范围分别是

0b101是二进制表示

（常量）在C语言中，以下哪些浮点常量(const)是合法的：
ABD

A. .1415
B. 3.
C. .e5
D. 1e-5

char <= short <= int <= long

unsigned char <= short <= int <=unsigned long

在C语言中，输出一个单引号’，正确的语句是：这两个
printf(“'”);
printf(“'”);

%x %o输出

unsigned int a = 0X17E 和unsigned int b = 0412,a和b谁的值更大？
A.a大

printf(“%d”, 06757);这个输出的是8进制

char和unsigned char的表示范围分别是：
D.-128 $\sim$ 127,0 $\sim$ 255

char a = 120;
char b = a+20;
printf(“%d %d\n”,a*2,b);

输出：
240 -116

unsigned int a = 513;
char b = a;
printf(“%d”,b);
输出：
1

int m = 2;
int n = 3;
n *= m++;
运行后n=6,m=3

让我们逐步解析这段代码，对其执行过程进行说明：

int a = 3;
printf("%d\n", (a += a -= a * a));

a * a：先计算表达式 a * a，即 3 * 3，结果为 9。
a -= 9：接着执行 a -= 9，即 a = a - 9，a 的当前值是 3，所以 a 变为 3 - 9，即 a 的值变为 -6。
a += -6：然后执行 a += -6，即 a = a + (-6)，此时 a 的当前值是 -6，所以 a 变为 -6 + (-6)，即 a 的值变为 -12。

因此，整个表达式的结果是 -12，然后使用 %d 格式化符号将其作为整数打印输出。执行结果会输出 -12。

sizeof()：
返回字节数

char 1
short 2
int 4
long 4
long long 8

//送一份归并排序给你
struct ListNode* merge(struct ListNode* list1, struct ListNode* list2) {
    if (list1 == NULL)
        return list2;
    if (list2 == NULL)
        return list1;//!
	struct ListNode *resl;
	if (list1->val <= list2->val) {
		resl = list1;
		list1 = list1->next;
	} else {
		resl = list2;
		list2 = list2->next;
	}
	struct ListNode *cur = resl;
	while (list1 && list2) {
		if (list1->val <= list2->val) {
			cur->next = list1;
			list1 = list1->next;
		} else {
			cur->next = list2;
			list2 = list2->next;
		}
		cur = cur->next;//!
	}
	if (list1)
		cur->next = list1;
	if (list2)
		cur->next = list2;
	return resl;
}

struct ListNode* sortList(struct ListNode* head) {	
	if (head == NULL || head->next == NULL)//!!
		return head;
	struct ListNode* slow = head, *fast = head->next;
	while (fast && fast->next) {
		slow = slow->next;
		fast = fast->next->next;
	}
	struct ListNode* mid = slow->next;
	slow->next = NULL;
	head = sortList(head);//!!
	mid = sortList(mid);
	return merge(head, mid);
}

#include <stdio.h>
#define ROW 3
#define COL 3

void matrixInput(int (*mat)[COL]);//数组的指针
void matrixPrint(int *mat[ROW]);//指针的数组
void matrixAddT(int *mat);//传一维



void matrixInput(int (*mat)[COL]) {
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            scanf("%d", &mat[i][j]);
}

void matrixPrint(int *mat[ROW]) {
    for (int i = 0; i < 3; i++) {
        printf("\n");
        for (int j = 0; j < 3; j++)
            printf("%d ", mat[i][j]);
    }

}

void matrixAddT(int *mat) {
    for (int i = 0; i < 3; i++)
        for (int j = i; j < 3; j++)
            mat[i * COL + j] += mat[j * COL + i];
    for (int i = 0; i < 3; i++)
       for (int j = 0; j < i; j++)
            mat[i * COL + j] = mat[j * COL + i];
}

??????????

参照这个
在这里插入图片描述

nymph181

关注

11
点赞
踩
6

收藏

觉得还不错? 一键收藏
1
评论
阐述程设理论2

p和q的值是一致的。A.定义了一个指向一维数组的指针p，所指向的一维数组具有5个char元素；C.int *p(char *a)表示一个形参与返回值均为指针的函数；D.int *p(char *a)：一个形参与返回值均为指针的函数；C.int p(char *a)：一个形参为指针的函数；实参(fun(1))，形参（fun(int a) ）C.指针的数据类型声明的是指针实际指向内容的数据类型；D.指针的数据类型声明的是指针实际指向内容的数据类型；C.y= *p(x);
复制链接

扫一扫