C语言复习第七天

最新推荐文章于 2024-08-10 07:03:33 发布
最新推荐文章于 2024-08-10 07:03:33 发布
阅读量213 收藏
点赞数
分类专栏： C语言温故 文章标签： 指针 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43790540/article/details/104121837
版权

C语言复习第七天

字符串典型问题

问题一

下面的程序输出什么?

#include <stdio.h>
int main()
{
    char buf[10] = {0};
    char src[] = "hello %s";
    
    snprintf(buf, sizeof(buf), src);
    
    printf("buf = %s\n", buf);
    
    return 0;
}

在这里插入图片描述
分析：
snprintf函数本身是可变参数函数，原型如下：
int snprintf(char* buffer,int buff_size,const char*fomart，…)
当函数只有三个参数时，如果第三个参数没有包含数任何的格式化信息，函数调用没有问题，相反，如果第三个参数包含了格式化信息，但缺少后续对应参数，则程序行为不确定。

上述代码正确使用案列

#include <stdio.h>

int main()
{
    char buf[13] = {0};
    char * str="world";
    char src[] = "hello %s";
    
    snprintf(buf, sizeof(buf), src,str);
    
    printf("buf = %s\n", buf);
    
    return 0;
}

在这里插入图片描述
因为第三个参数中包含了 %s的格式化信息，所以我们要为其填入值，否则函数行为不正确。

问题二

下面的程序输出什么：

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

int main()
{
    #define STR  "Hello  chen\0 moqian\0 "
    
    char* src = STR;
    char buf[255] = {0};
    
    snprintf(buf, sizeof(buf), src);
    
    printf("strlen(STR) = %d\n", strlen(STR));
    printf("sizeof(STR) = %d\n", sizeof(STR));
    
    printf("strlen(src) = %d\n", strlen(src));
    printf("sizeof(src) = %d\n", sizeof(src));
    
    printf("strlen(buf) = %d\n", strlen(buf));
    printf("sizeof(buf) = %d\n", sizeof(buf));
    
    printf("src = %s\n", src);
    printf("buf = %s\n", buf);
    
    return 0;
}

在这里插入图片描述
分析：
主要区别字符指针，字符数组，字符串的不同。

  1. 字符串相关的函数均以第一个出现的==’\0’作为结束符==
  2. 编译器总是会在字符串字面量的末尾添加’\0’
  3. 字符串字面量的本质为数组

典型问题三

下面的程序输出什么？

#include <stdio.h>
#define S1 "hello chenmo"
#define S2 "hello chenmo"

int main()
{
  if(S1==S2)
  {
   printf("Equal\n");
  }
  else
  {
  	printf("Non Equal\n");
  }
   if( strcmp(S1, S2) == 0 )
    {
        printf("Equal\n");
    }
    else
    {
        printf("Non Equal\n");
    }
  retun 0;
}

gcc编译效果：
在这里插入图片描述
vs编译效果:
在这里插入图片描述
分析:

  1. 字符串之间的相等比较需要用strcmp完成
  2. 不可直接用= =进行字符串直接的比较
  3. == 完全相同的字符串字面量的比较结果为false

tips:
一些现代编译器能够将相同的字符串字面量映射到同一个无名字符数组，因此==比较为true.
例如：现在的gcc，mscv编译器都用优化，但是还是使用strcmp比较好。

典型问题四

编程例题
高效率：
循环左右移动字符串：

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

//字符串右移
void right_shift_r(const char* src,char*result,unsigned int n)
{
	const unsigned int LEN=strlen(src);
	for(int i=0;i<LEN;i++)
	{
	 result[(n+i)%LEN]=src[i];
	}
	result[LEN]='\0';
}

//字符串左移
void left_shift_l(const char* src,char*result,unsigned int n)
{
	const unsigned int LEN=strlen(src);
	for(int i=0;i<LEN;i++)
	{
	 i<n? (result[LEN-n+i]=src[i]):(result[i-n]=src[i]);
  }
   result[LEN]='\0';
}

int main()
{
    char result[255] = {0};
    
    right_shift_r("abcde", result, 2);
    
    printf("%s\n", result);
    
    left_shift_l("abcde", result, 2);
    
    printf("%s\n", result);
    
    return 0;
}

在这里插入图片描述

数组指针和指针数组分析

数组指针

数组类型

  1. C语言中的数组有自己的特定的类型
  2. 数组的类型由元素类型和数组大小共同决定
    例
int array[5] 的类型为 int[5]

定义数组类型

  1. C语言中通过==typedef ==为数组类型重命名
				typedef type(name)[size];

	——数组类型:

				typedef int(AINT5)[5];
				typedef float(AFLOAT10)[10];

	——数组定义:
						AINT5 iArray;
						AFLOAT fArray;

数组指针

  1. 数组指针用于指向一个数组
  2. 数组名是数组首元素的起始地址，但并不是数组的起始地址。
  3. 通过将取地址符&作用于数组名可以得到数组的起始地址
  4. 可通过数组类型定义数组指针 ArrayType*pointer;
  5. 也可以直接定义:type(*pointer)[n];
    ——pointer为数组指针变量名
    ——type为指向的数组的元素类型
    ——n为指向的数组的大小

示例

#include <stdio.h>
#include <stdlib.h>
typedef int(AINT5)[5];
typedef float(AFLOAT10)[10];
typedef char(ACHAR9)[9];


void str_length(char(*pcw)[9])
{
   printf("size=%d\n",sizeof(*pcw));
}

int main()
{
    AINT5 a1;
    float fArray[10];
    AFLOAT10* pf = &fArray;
    ACHAR9 cArray;
   
    char(*pc)[9] =&cArray;
    char(*pcw)[9]=&cArray;
    char(*pcww)[4]=&cArray;
    char * pcc=cArray;
    float * pff=fArray;
    //int i = 0;
    
    printf("%d, %d\n", sizeof(*pcw), sizeof(*pcww));
    str_length(pcw);
    for(int i=0; i<10; i++)
    {
        (*pc)[i]=48+i;
        (*pf)[i]=i;
    }
    
     for(int i=0; i<10; i++)
    {
        printf("%p\n", &(*pc)[i]);
    }
    printf("Begin\n");
     for(int i=0; i<10; i++)
    {
       
       printf("pcww[%d]=%c\n",i, (*pcww)[i]);
       printf(" pcw[%d]=%c\n",i, (*pcw)[i]);
    }
    
    printf("%p, %p, %p\n", &cArray, pc+1, pcw+1);

    return 0;
}

在这里插入图片描述

解析:

主要区分:
(*pcww)[i]  // 指的是取数组指针指向的数组中的第i个元素
*pcww[i]    //指的是取pcww为首地址+i之后的地址的值
		    //地址计算为： pcww+(*pcww)*i 取前面式子中的地址存放的值

指针数组

  1. 指针数组是一个普通的数组
  2. 指针数组中每个元素为一个指针
  3. 指针数组的定义:type* pArray[n];

==type*==为数组中每个元素的类型
pArray为数组名
n为数组大小

使用示例：//利用字符指针数组查找元素

#include <stdio.h>
#include <string.h>
#define DIM(a) (sizeof(a)/sizeof(*a))
int lookup_keyword(const char* key, const char* table[], const int size)
{
    int ret = -1;
    
    int i = 0;
    
    for(i=0; i<size; i++)
    {
        if( strcmp(key, table[i]) == 0 )
        {
            ret = i;
            break;
        }
    }
    
    return ret;
}
int main()
{
    float farray[3]={1,2,3};
    float* pFloat[3];
    for(int i=0;i<3;i++)
    {
      pFloat[i]=&farray[i];
    }
    for(int i=0;i<3;i++)
    {
      printf("%f\n",*pFloat[i]);
    }
    for(int i=0;i<3;i++)
    {
      *pFloat[i]=i+3;
    }
    for(int i=0;i<3;i++)
    {
      printf("%f\n",*pFloat[i]);
    }
    
    const char* keyword[] = {
            "do",
            "for",
            "if",
            "register",
            "return",
            "switch",
            "while",
            "case",
            "static"
    };
    
    printf("%d\n", lookup_keyword("return", keyword, DIM(keyword)));
    printf("%d\n", lookup_keyword("main", keyword, DIM(keyword)));
    return 0;
}

小结

  1. 数组的类型由元素类型和数组大小共同决定
  2. 数组指针是一个指针，指向对应类型的数组
  3. 指针数组是一个数组，其中每个元素都为指针
  4. 数组指针遵循指针运算法则
  5. 指针数组拥有C语言数组的各种特性

main函数与命令行参数

main函数的概念

  1. C语言中的main函数称之为主函数
  2. 一个C程序是从main函数开始执行的

main函数的本质

  1. main函数是操作系统调用的函数
  2. 操作系统总是将main函数作为应用程序的开始
  3. 操作系统将main函数的返回值作为程序的退出状态
    编程示例：
//a.c
#include <stdio.h>

int main()
{
    printf("I'm A!\n");
    return 1;
}

//b.c
#include <stdio.h>

int main()
{
    printf("I'm B!\n");
    return 99;
}

gcc中通过echo查看上次程序运行的返回值。
在这里插入图片描述
同时可以编写shell脚本根据返回值，来执行下一个程序。
示例：

#!/bin/sh

./a                        # 运行a程序
a=$?					   #将a程序的返回值保存在a变量中
if [ "$a" != "0" ]         #通过if判断，语法注意，前后两个空格必须加。
then
  ./b
fi

echo "a is"
echo $a

运行结果
在这里插入图片描述

main函数的参数

  1. 程序执行时可以向main函数传递参数
    ——int main()
    ——int main(int argc)
    ——int main(int argc,charargv[])
    ——int main(int argc,char    argv[],char*env[]) //命令行参数个数，命令行参数数组，环境变量数组

示例:

#include <stdio.h>

int main(int argc, char* argv[], char* env[])  //命令行参数个数，命令行参数数组，环境变量数组
{
    int i = 0;
    
    printf("============== Begin argv ==============\n");
    
    for(i=0; i<argc; i++)
    {
        printf("%s\n", argv[i]);
    }
    
    printf("============== End argv ==============\n");
    
    printf("\n");
    printf("\n");
    printf("\n");
    
    printf("============== Begin env ==============\n");
    
    for(i=0; env[i]!=NULL; i++)
    {
        printf("%s\n", env[i]);
    }
    
    printf("============== End env ==============\n");

    return 0;
}

在这里插入图片描述

main函数一定是程序执行的第一个函数吗？

gcc编译器和一些现代的编译器，支持在main函数之前和之后执行函数。
示例： 通过attribute属性关键字

#include <stdio.h>

#ifndef __GNUC__
#define __attribute__(x) 
#endif

__attribute__((constructor))
void before_main()
{
    printf("%s\n",__FUNCTION__);
}

__attribute__((constructor))
void befor_main1()
{
  printf("%s\n",__FUNCTION__);
}

__attribute__((destructor)) 
void after_main()
{
    printf("%s\n",__FUNCTION__);
}

int main()
{
    printf("%s\n",__FUNCTION__);
    
    return 0;
}

在这里插入图片描述

小结

  1. 一个C程序是从main函数开始执行的
  2. main函数是操作系统调用的函数
  3. main函数有参数和返回值
  4. 现代编译器支持在main函数前后调用其他函数

多维数组和多维指针

指向指针的指针

  1. 指针的本质是变量
  2. 指针会占用一定的内存空间
  3. 可以定义指针的指针来保存指针变量的地址值

示例：通过指针的指针来改变指针的指向（即在指针保存的变量地址）

#include <stdio.h>

int main()
{
    int i=3;
    int *p=NULL;
    int** pp=NULL;
    
    p=&i;
    pp=&p;
    
    printf("*p =%d\n",*p);
    printf("p  =%p\n",p);
    printf("pp =%p\n",pp);
    printf("*pp=%p\n",*pp);
    
    int a=6;
    *pp=&a;
    printf("*p =%d\n",*p);
    printf("p  =%p\n",p);
    printf("pp =%p\n",pp);
    printf("*pp=%p\n",*pp);
    return 0;
}

在这里插入图片描述

重置动态空间的大小

  1. 为什么需要指向指针的指针？
    ——指针在本质上也是变量
    ——对于指针也同样存在传值调用与传址调用
    示例：重置动态空间的大小
#include <stdio.h>
#include <malloc.h>

int reset(char **pp,int size,int new_size)
{
    int ret=1;
    int len=0;
    char *temp=NULL;
    char *p= *pp;
    char *pt=NULL;
    
    if((new_size>0)&&(pp!=NULL))
    {
      len=new_size<size?new_size:size;
      pt=(char*)malloc(sizeof(char)*len);
      temp=pt;
      for(int i=0;i<len;i++)
      {
        *temp++=*p++;
      }
      free(*pp);
      *pp=pt;
    }
    else
    {
      ret=0;
    }
    return ret;
}

int main()
{
   char *p=(char*)malloc(sizeof(char)*5);
   char pp[]="hello";
   for(int i=0;i<5;i++)
   {
     p[i]=48+i;
   }
    printf("%p\n", p);
    printf("%u\n",strlen(p));
    printf("%u\n",sizeof(pp));
    if( reset(&p, 5, 3) )
    {
        printf("%p\n", p);
        printf("%u\n",strlen(p));
    }
   
   free(p);
  

}

在这里插入图片描述

二维数组与二级指针

  1. 二位数组在内存中以一维的方式排布
  2. 二维数组中的第一维是一维数组
  3. 二维数组中的第二维才是具体的值
  4. 二维数组的数组名可以看作常量指针
    示例：遍历二维数组
#include <stdio.h>
#include <malloc.h>

void printArray(int a[], int size)
{
    int i = 0;
    
    printf("printArray: %d\n", sizeof(a));

    for(i=0; i<size; i++)
    {
        printf("%d\n", a[i]);
    }
}

int main()
{
    int a[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
    int* p = &a[0][0];
    
    int i = 0;
    int j = 0;
    
    for(i=0; i<3; i++)
    {
        printf(" %p\n ", *(a+i));  //查看第一维，第一维实际就是有多个指针构成的。
        printf("%p\n ", a[i]);     //查看第一维
        for(j=0; j<3; j++)
        {
            printf("%d, ", *(*(a+i) + j));
        }
        
        printf("\n");
    }
    
    printf("\n");
    
    printArray(p, 9);
    
    return 0;
}

在这里插入图片描述
tips
从打印结果明显可以看出，二位数组的第一维明显就是个指针，第一维其实就是数组指针

数组名

  1. 一维数组名代表数组首元素的地址
    ——int a[5] a的类型为int *
  2. 二维数组名同样代表数组首元素的地址
    ——int a[2][5] a的类型为int(*)[5]

== 结论：==

  1. 二维数组名可以看做是指向数组的常量指针（即为数组指针）
  2. 二维数组可以看做是一维数组
  3. 二位数组中的每个元素都是同类型的一维数组

示例：（如何动态申请二位数组）

#include <stdio.h>
#include <malloc.h>


int **malloc2d(int row,int col)
{
  int **ret=NULL;
  if((row>0)&&(col>0))
  {
   ret=(int**)malloc(sizeof(int *)*row);
   int *p=(int *)malloc(sizeof(int)*row*col);
    if((ret!=NULL)&&(p!=NULL))
    {
      for(int i=0;i<row;i++)
      {
        ret[i]=p + i*col;
      }
    }
    else
    {
      free(ret);
      free(p);
      ret=NULL;
      p=NULL;
    }
  }
  return ret;
}

void free2d(int **p)
{
    if(*p!=NULL)
    {
      free(*p);
    }
    free(p);
}

int main()
{
    int** a = malloc2d(3, 3);
    int i = 0;
    int j = 0;
    
    for(i=0; i<3; i++)a
    {
        for(j=0; j<3; j++)
        {
            printf("%d, ", a[i][j]);
        }
        
        printf("\n");
    }
    
    free2d(a);
  return 0;
}

在这里插入图片描述

小结

  1. C语言只支持一维数组
  2. C语言中的数组大小必须在编译期就作为常数确定
  3. C语言中的数组元素可是任何类型的数据
  4. C语言中的数组的元素可以是另一个数组

数组参数和指针参数分析

为什么C语言中的数组参数会退化为指针？

退化的意义

  1. C语言中只会以值拷贝的方式传递参数
  2. 当向函数传递数组时：
    ——将整个数组拷贝一份传入函数 ❌
    ——将数组名看做常量指针传数组首元素地址 ✔

tips:
C语言以高效作为最初设计目标：

  1. 参数传递的时候如果拷贝整个数组执行效率将大大下降
  2. 参数位于栈上，太大的数组拷贝将导致栈溢出

二位数组参数

  1. 二位数组参数同样存在退化的问题
    ——二维数组可以看做是一维数组
    ——二维数组中的每个元素是一维数组
  2. 二维数组参数中第一维的参数可以省略
    ——void f(int a[5]) <——>void f(int a[])<——>void f(int *a)
    ——void g(int a[3][3])<——>void g(int a[][3])<——>void g(int(*a)[3])

等价关系:

数组参数等效的指针参数
一维数组:float a[5]指针: float* a
指针数组:float *a[5]指针的指针：float **a
二维数组:float a[3][5]数组指针：float(*a)[5]

被忽视的知识点

  1. C语言无法向一个函数传递任意的多维数组
  2. 必须提供除第一维之外的所有维的长度
    ——第一维之外维度信息用于完成指针运算
    ——N维数组的本质是一维数组，元素是N-1维的数组
    ——对于多维数组的函数参数只有第一维是可变的
    示例分析:
#include <stdio.h>

void access(int a[][3], int row)
{
    int col = sizeof(*a) / sizeof(int);
    int i = 0;
    int j = 0;
    
    printf("sizeof(a) = %d\n", sizeof(a));
    printf("sizeof(*a) = %d\n", sizeof(*a));
    
    for(i=0; i<row; i++)
    {
        for(j=0; j<col; j++)
        {
            printf("%d\n", a[i][j]);
        }
    }
    
    printf("\n");
}

void access_ex(int b[][2][3], int n)
{
    int i = 0;
    int j = 0;
    int k = 0;
    
    printf("sizeof(b) = %d\n", sizeof(b));
    printf("sizeof(*b) = %d\n", sizeof(*b));
    printf("sizeof(*b) = %d\n", sizeof(**b));
    for(i=0; i<n; i++)
    {
        for(j=0; j<2; j++)
        {
            for(k=0; k<3; k++)
            {
                printf("%d\n", b[i][j][k]);
            }
        }
    }
    
    printf("\n");
}

int main()
{
    int a[3][3] = {{0, 1, 2}, {3, 4, 5}, {6, 7, 8}};
    int aa[2][2] = {0};
    int b[1][2][3] = {0};
    
    access(a, 3);
    // access(aa, 2);     warning
    access_ex(b, 1);
    // access_ex(aa, 2);  warning
    
    return 0;
}

在这里插入图片描述

小结

  1. C语言中只会以值拷贝的方式传递参数
  2. C语言中的数组参数必然退化为指针
  3. 多维数组参数必须提供除第一维之外的所有维长度
  4. 对于多维数组的函数参数只有第一维是可变的
嵌入式-沉默
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言第四章顺序结构复习题.doc
12-21
C语言第四章顺序结构复习题 本资源是一份C语言第四章顺序结构的复习题，涵盖了顺序结构程序设计的基础知识点，包括赋值语句、printf函数、scanf函数、变量定义和赋值、运算符优先级等。 知识点1：赋值语句 赋值...
C语言进阶－第2讲C语言复习共25页.pdf.zip
11-22
标题"**C语言进阶－第2讲C语言复习共25页.pdf.zip**"表明这是一个关于C语言进阶学习的资料，具体是第二讲的内容，包含25页的复习材料。这通常是一份教程或者课程笔记，涵盖了C语言的深入知识点，可能是对基础概念的...
_snprintf_s()函数的正确用法
zhangmiaoping23的专栏
07-21 4万+
_snprintf_s()函数的n代表最多复制多少个字符，函数名尾部_s表示检测缓冲区溢出，微软特有的检测。 正确用法如下： char szTable[27] = "abcdefghijklmnopqrstuvwxyz"; char szBuffer[10] = { 0 }; //将会崩溃，因为会发生缓冲区溢出 //_snprintf_s(szBuffer, sizeof(szBu
C语言复习
yrr999的博客
03-06 2671
C语言复习笔记1 一、数据类型、运算符与表达式 1.常量与变量 （1）常量分为：整型常量、实型常量、字符常量、字符串常量和符号常量。如：15是整型常量，3.14159是实型常量，‘a’是字符常量，"abc123"是字符串常量. （2）变量是指在程序运行过程中其值可以改变的量. 2.整型常量 （1）三种形式： 十进制：以非0开始的数，数码取值范围是0～9，可以是正数、负数，如25、-36、+23等。 八进制：以0开始的数，数码取值为0～7，如037、0123等。 十六进制：以0x或0X开始的数，数码取值为0～
C语言重点复习大纲
wtl666_6的博客
01-30 7917
C语言重点复习大纲
C语言 快速复习
阿林爱吃大米饭的博客
02-26 225
快速复习C语言语法
大一C语言复习题库
假技术Po主
12-26 2万+
一、单项选择题（每小题2分，共50分） 1、一个C程序的执行是从__A___。 A、本程序的main函数开始，到main函数结束 B、本程序的main函数开始，到本程序文件的最后一个函数结束 C、本程序文件的第一个函数开始，到本程序文件的最后一个函数结束 D、本程序文件的第一个函数开始，到本程序main函数结束 2、C语言程序的基本单位是___C___。 A、程序行 ...
C语言基础期末复习题（带详解答案）
热门推荐
爱德苏的博客
01-05 7万+
人类高质量C语言期末复习题！
学习C语言的第七天
m0_74108945的博客
01-11 73
断了一个月没有更新了，果然坚持学习很难啊，今天继续开始记录C语言的学习之路复习了一下计算机的存储数据的方式，以二进制方式存储的提到了二进制所以就把二进制转换复习了如下图++i意思为在使用i之前，先使i的值加1，i++意思为在使用i之后，再使i加1例如：i=3//输出结果为4若改为print("%d",i++);//输出结果为3输出结果为：a97在需要转换的表达式前面加上（类型名），注意表达式也要括号括起来如：(int)(x+y)
C语言复习第一天---谭浩强第一章练习
fcxgfdjy的博客
01-20 553
前言 因为是大一上才学的c语言，最近已经没有碰c语言很长一段时间了，想趁着这个寒假复习一下，为刚开学的计算机二级作准备。 第一章 1.编写一个C程序，运行时输出以下图形： // A code block var foo = ‘bar’; ```javascript ***** ***** ***** ****** ...
第七章数组答案C语言,C语言复习题及答案-第七章-数组
weixin_31640385的博客
05-18 393
.WORD版本第七章数组 (8学时)学习目的与要求：1 、重点掌握一维数组的定义和引用；2 、基本掌握二维数组的定义和引用；3 、重点掌握字符型数组的定义与引用；4 、能正确使用字符串处理函数；5 、学会使用数组解决实际问题。重点：1 、一维数组的定义与引用；2 、二维数组的定义与引用；3 、字符数组的定义与引用；第1讲知识归纳：1、一维数组的定义：类型说明符数组名[ 常量表达式 ] ；(1)(1...
C语言程序设计 谭浩强 复试复习笔记自用
wfs66的博客
02-28 1293
这意味着，当你将一个数组传递给函数时，函数会接收到一个指向数组第一个元素的指针，而不是数组的副本。重要的是要理解，传递的是指向第一行的指针，而不是整个二维数组的内容。同时，传递的指针是常量指针，意味着你不能在函数内部改变它指向的地址，但你可以通过这个指针来修改数组元素的值。赋值运算符，若有a=b=c，按从右到左的顺序，先把c的值赋给b，再把b的值赋给a（即=的结合性是从右向左的）。整个赋值表达式的值为被赋予的值。数组索引是从0开始的，所以第一个元素的索引是0，第二个元素的索引是1，依此类推。
C语言复习习题及答案资料.ppt
11-15
【C语言复习习题及答案】这份资料涵盖了C语言的基础知识和常见问题，主要涉及到数组相关的习题。下面是其中的一些重点知识点的详细解释： 1. **数组定义与初始化**： - 在C语言中，数组定义如`int a[8];`只声明了...
C语言复习题库(1)C语言复习题库(1)
03-09
### C语言复习题库知识点详解 #### 一、填空题知识点分析 1. **程序的基本结构**： - **顺序结构**：是最简单的结构，按照代码书写的先后顺序逐条执行。 - **选择结构**：根据条件来决定执行哪部分代码，如 `if....
专升本C语言复习资料-第1章 程序设计和C语言
03-16
7. **学习与复习建议**： - 对于专升本C语言的学习，要理解并掌握C语言的基础概念、语法和程序结构。 - 通过大量练习题强化对知识点的理解和应用能力，特别关注程序设计的基本流程和问题解决方法。 - 注重对C语言...
顺序表各种接口的实现(C)
最新发布
CoderZzz6310的博客
08-10 717
数据结构中顺序表的增删查改的实现
1.3 C 语言入门实战：从 Hello World 到基础语法解析
Thanks_ks的IT探秘之旅
08-08 1190
本文深入解析了 C 语言学习的起点，从"Hello World"程序入手，引导读者新建项目并理解其基本构成。进一步探讨 printf 函数的基本用法，解锁打印输出的秘密。同时，详细讲解了单行与多行注释的方法，特别提醒了嵌套注释的误区。最后，指导读者理解项目文件在磁盘上的存储位置，为构建坚实编程基础奠定良好开端。适合 C 语言初学者快速上手，掌握核心基础。
C. Mr. Perfectly Fine
无知的我
08-06 939
解题说明：此题是一道模拟题，可以采用贪心算法，找出包含1和10的耗费最小时间组合或者是直接包含11的最小时间，两者进行比较即可。
C语言项目——贪吃蛇，为什么用curses，定义上下左右
CLO_se_的博客
08-07 236
使用curse，他可以及时响应，不用像 scanf 和 getchar 这两个需要回车键响应。在Linux系统中，使用ncurses在程序编译时还要加上 -lcurses。函数keypad设置了可以在stdscr中接受键盘的功能键（除字母外的按键）恒定义 ： vi / usr / include / curses.h。即：gcc cursedemo.c -lcurses。这对于我们贪吃蛇上下左右键的响应十分有作用。
C语言复习选择题集锦
"这是一份针对谭浩强版C语言的复习资料，包含了多项选择题，旨在帮助大一学生准备考试。题目涵盖了C语言的基本...以上就是这份C语言复习题中涉及的主要知识点的详细解释。掌握这些内容对于理解和编写C程序至关重要。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值