c语言学习第二周

C基础day5

##while

格式：
定义循环变量并赋初值
while(终止条件)
{
语句块；
增值减值；
}
执行顺序：先定义循环变量并赋初值，判断终止条件是否成立，如果成立就进入循环执行语句块和增值减值语句，继续判断终止条件是否成立，直到不成立循环结束

do_while
格式：
定义循环变量并赋初值
do
{
语句块；
增值减值语句；
}while(终止条件)；

执行顺序：先执行后判断

循环控制语句

break:结束整个循环
continue :结束本次循环，继续下一次循环
使用场景：用于循环中，用于结束循环
使用时需要有判断条件

练习：从终端上输入一个字符并在终端上输出这个字符，当输入字符为‘q’时，程序结束

#include<stdio.h>
int main(int argc, char const *argv[])
{
    char ch;
    while(1)
    {
        scanf("%c",&ch);
        if(ch == '\n')
            continue;
        if(ch == 'q')
            break;
        printf("%c\n",ch);
        // getchar();
    }
    return 0;
}

数组
1.概念：具有一定顺序的若干变量的集合
2.定义格式：
存储类型 数据类型 数组名[元素个数]；
int arr[5];
数组名：代表数组的首地址，地址常量，不能被赋值，不能执行自加操作

访问元素：数组名[下标]，下标从0开始，一直到n-1,
一定要注意数组越界问题

3.初始化
1）全部初始化：
int a[5]={1,2,3,4,5};//1 2 3 4 5
等效于：a[0]=1;a[1]=2;a[2]=3;a[3]=4;a[4]=5;

2）部分初始化：未被赋初值的元素值为0
int a[5]={1,2,3};//1 2 3 0 0

3）未初始化：未赋初值时为随机值，需要单独赋值
int a[5];//全为随机值
a[2]=3;//随机值 随机值 3 随机值 随机值

练习：从终端上输入一个字符并在终端上输出这个字符，当输入字符为‘q’时，程序结束。

#include<stdio.h>
int main(int argc, char const *argv[])
{
    char ch;
    while(1)
    {
        scanf("%c",&ch);
        if(ch == '\n')
            continue;
        if(ch == 'q')
            break;
        printf("%c\n",ch);
        // getchar();
    }
    return 0;
}

C基础day6

一、 字符数组
1.概念：数据类型为字符型的数组
2.存在三种形式：
1)char a[]={‘a’,‘b’,‘c’};//逐个字符赋值，sizeof(a)=3
2)char b[]={“hello”};//用字符串常量赋值，sizeof(b)=6
3) char c[]=“hello”;//用字符串常量赋值，sizeof©=6

长度：sizeof(数组名)/sizeof(数据类型)
注意：字符串赋值经常省略元素个数（数组长度），要注意数组越界问题

练习2：将一串字符串进行倒置，例如：char buf[32]=”hello”;//olleh

#include<stdio.h>
int main(int argc, char const *argv[])
{
    char buf[32]={};
    scanf("%s",buf);
    int i,n;
    char ch;
    for(n=0;buf[n]!='\0';n++);//n字符串的实际长度,\0的下标

    for(i=0;i<n/2;i++)//交换次数：n/2次
    {
        ch = buf[i];
        buf[i]=buf[n-1-i];
        buf[n-1-i]=ch;
    }
    printf("%s\n",buf);
    return 0;
}

二、计算字符串的实际长度：
1.通过循环遍历数组直到\0为止for(n=0;buf[n]!=‘\0’;n++);
2.strlen
#include <string.h>
size_t strlen(const char *s);
功能：计算字符串的实际长度，不包括\0
参数：s:要计算的字符串的首地址
返回值：字符串的实际长度

例子：
char a[32]=“hello”;
int t = strlen(a);//5
int ret = sizeof(a);//32

char a[]="hello";
int t = strlen(a);//5
int ret = sizeof(a);//6

三、sizeof和strlen区别
1.sizeof是关键字，strlen是函数
2.sizeof是计算数据所占空间大小，strlen是计算字符串的实际长度
3.sizeof包括\0，strlen不包括\0；在字符数组中，省略元素个数时，sizeof比strlen大1

四、冒泡和选择排序
算法实现：
n个数排序
for(i=0;i<n-1;i++)//轮数
for(j=0;j<n-1-i;j++)//每轮比较的次数
if(a[j]>a[j+1])//如果前面大就交换
{
t=a[j];
a[j]=a[j+1];
a[j+1]=t;
}

选择排序：
排序过程：
1)首先通过n-1次比较，在n个数中找出最小值，将它与第一个元素交换
2)再通过n-2次比较，在剩下的n-1个数中找出最小值，将它与第二个元素交换
3)重复上述过程，经过n-1轮排序后排序结束

算法：
for(i=0；i<n-1;i++)//轮数
{
k = i;
for(j = i+1;j<n;j++)//比较次数，找最小值
{
if(a[j]<a[k])//如果比当前最小值还小
k = j;//暂存最小值下标
}
if(k != i)//判断需不需要交换
{
t = a[k];
a[k]=a[i];
a[i]=t;
}
}

C基础day7

【1】二维数组
1.格式：存储类型 数据类型 数组名【行数】【列数】；
int a[3][2];
访问元素：数组名[行下标][列下标]；（下标从0开始，到行数-1，列数-1）
注意：行下标和列下标都不能越界
可以省略行数，不能省略列数
2.元素个数：
行*列
3.数组名：
a:表示第一行首地址
a+1:表示第二行首地址
4.初始化：

1）全部初始化：
int a[2][3]={1,2,3,4,5,6};//1 2 3 4 5 6
int a[2][3]={{1,2,3},{4,5,6}};//1 2 3 4 5 6
		 第一行   第二行
2）部分初始化：未赋初值的元素值为0
int a[2][3]={1，2，3，4}；//1 2 3 4 0 0
int a[2][3]={{1，2}，{3，4}}// 1 2 0 3 4 0
3）未初始化：未赋初值的元素值为随机值，需要单独赋值
int a[2][3];
a[0][0]=1;
a[1][0]=2;

【2】指针
1.概念
地址：内存中每个字节都有一个编号，这个编号就是地址
指针：指针就是地址
指针变量：用于存放地址的变量
2.格式:
存储类型 数据类型 * 变量名
int * p;
int a=5;
int * p = &a;
char ch = ‘b’;
char * q = &ch;
3.指针操作符
&：取地址 取变量的地址
*： 取内容 取地址里面的内容

*和&互逆，可以相互抵消
4.初始化
指针变量使用前不仅要定义还要初始化，没有初始化的指针不能随便使用，会产生野指针

1）将普通变量的地址赋值给指针变量
	int a=10;
1)int *p = &a;
printf("%d %d\n",a,*p);//10 10
printf("%p %p\n",&a,p);
*p = 20;//可以通过修改*p修改指向变量的值
printf("%d %d\n",a,*p);//20 20
2)int *p = NULL;
p=&a;
2)将数组的首地址赋值给指针变量
char s[10]="hello";
char * p = s;//指针p指向字符数组的首地址，也就是'h'的地址
printf("%c\n",*p);//h
3) 将指针变量里保存的地址赋值给另一个指针变量
int a=5;
int *p = &a;
int *q = p;

5.指针运算：
1）算术运算：
p++:指针向高地址方向移动一个数据单位，指针的指向发生变化
p–:指针向低地址方向移动一个数据单位，指针的指向发生变化
p+n:访问高地址方向第n个数据的地址，指针的指向不会发生变化
p-n:访问低地址方向第n个数据的地址，指针的指向不会发生变化
两个地址之间的差使两个地址之间元素的个数，不是字节数
2）关系运算：
> < == !=
指针的关系运算比较的是指针指向的地址的高低
int a[5]={1,2,3,4,5};
int * p =a;
int *q = &a[3];
p < q
在同一个数组中进行关系运算
6.指针的大小
sizeof(指针变量名) = 4字节
总结:
1.32位操作系统，占4字节；64位操作系统，占8字节
2.内存的地址是固定的，但是变量是随机存储
3.指针的类型是根据指向空间的数据的数据类型决定的
7.段错误
Segmentation fault (core dumped)
1）野指针
产生原因：
1）没有初始化；
2）指针free之后没有置为NULL;
解决：int * p =NULL;
2）对非法空间进行赋值

C基础day8

字符串倒置(用指针实现) 如：hello->olleh

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

int main(int argc, char const *argv[])
{
    char s[32]="";
    char t;
    scanf("%s",s);
    char * p = s;
    char * q = p+strlen(s)-1;
    while( p < q)
    {
        t = *p;
        *p = *q;
        *q = t;
        p++;
        q--;
    }
    printf("%s\n",s);
    return 0;
}

【1】指针修饰
1.const常量化
1）const int a = 10;//int const a = 10;
a=20;//报错，a被const修饰,不能被赋值；但是可以通过指针修改*p来改变a里面的值
2)const int p;//const修饰p,指针的指向可以修改，指针指向的内容不能修改
int const *p;
int a = 10;
const int * p = &a;
a)p =20;//报错，const修饰p,不能被赋值
b)int b=20;
p=&b; //可以，可以修改指针指向
3)int * const p;//const修饰p,指针的指向不能修改，指针指向的内容可以修改
int a = 10;
int b = 20;
int * const p = &a;
a)*p = 20;//可以
b) p = &b;//报错，const修饰p,不能被赋值
【2】大小端
超过一个字节的数据进行存储时，存在存储数据的顺序不同
大端：低地址存高字节数据，高地址存低字节数据
小端：低地址存低字节数据，高地址存高字节数据

0x12345678 0x4000
0x4000 0x4001 0x4002 0x4003
大端： 0x12 0x34 0x56 0x78
小端： 0x78 0x56 0x34 0x12

【6】指针数组
1.定义：本质是数组，里面存放指针
2.格式：存储类型 数据类型 * 数组名[元素个数]
int * a[3];
应用示例：

1）用于存放普通变量的地址
	int a=10,b=20,c=30;
	int *p[3]={&a,&b,&c};
	访问b的值：
	*p[1]		*(*(p+1))
	访问b的地址：
	p[1]		*(p+1)
2)用于存放二维数组每行第一列元素的地址
int a[2][3]={1,2,3,4,5,6};
int * p[2]={a[0],a[1]};
访问a[1][2]的值：
*(p[1]+2)	*(*(p+1)+2)
访问a[1][2]的地址：
p[1]+2	*(p+1)+2
	
sizeof(p)=8；//p是数组，内含2个指针
3）用于存放字符串
char *p[3]={"hello","world","hqyj"};
打印world字符串
printf(“%s\n”,p[1]);
printf(“%s\n”,*(p+1));
打印world字符串里面的字符d
printf("%c\n",*(p[1]+4));
printf("%c\n",*(*(p+1)+4));
4)命令行传参
int main(int argc, char const *argv[])
{
	return 0；
}
argc:  argv数组内元素的个数
argv：指针数组，存放命令行传递的字符串

C基础day9

已知字符数组a[10]和b[10]中元素的值递增有序，用指针实现将两个数组中元素按照递增顺序输出。

#include <stdio.h>
int main(int argc, char const *argv[])
{
    char a[10] = "acdgjmno";
    char b[10] = "befhil";
    char *p = a;
    char *q = b;
    while(*p && *q)
    {
        if(*p < *q)
        {
            printf("%c",*p);
            p++;
        }
        else
        {
            printf("%c",*q);
            q++;
        }  
    }
    if(*p == '\0' && *q )
        printf("%s\n",q);
    else if(*q == '\0' && *p)
        printf("%s\n",p);
    return 0;
}

给定一串字符"I love china",实现以单词为单位的逆序，如：“china love i”
思路：可以先全部倒过来：anihc evol i,然后再把每个单词倒过来

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

int main(int argc, char const *argv[])
{
    char a[32] = "";
    scanf("%[^\n]", a);
    char *p = a;
    char *q = p + strlen(a) - 1;
    char *k = NULL;
    char t;
    while (p < q)
    {
        t = *p;
        *p = *q;
        *q = t;
        p++;
        q--;
    }
    printf("%s\n", a); //全部倒置
    p = q = a;
    while (*p) //遍历整个字符串
    {
        while (*p == ' ')
            p++;
        q = p;
        while (*q != ' ' && *q != '\0')
            q++;
        k = q; //暂存空格地址
        q--;   //指向单词结尾
        while (p < q)//单词倒置
        {
            t = *p;
            *p = *q;
           *q = t;
            p++;
            q--;
        }
        p = k;
    }
    printf("%s\n", a);
    return 0;
}

【1】函数
1.定义：一个完成特定功能的代码模块
2.三要素：功能、参数、返回值
3.格式：
存储类型 数据类型 函数名（参数列表）
{
函数体；
return 表达式；
}
1）没有参数：参数列表可以省略，或void
2)没有返回值：数据类型为void ,内部可以省略return语句
3)有返回值：要根据返回值的类型定义函数的数据类型
注意：定义子函数的时候可以直接定义在被调用位置的前面，也可以定义在被调用函数位置的后面，但是需要提前进行函数声明。
4.函数声明：
存储类型 数据类型 函数名（参数列表）；
5.函数调用：
1）没有返回值：直接调用 函数名（实参）；
2）有返回值：如果需要接收返回值：就定义同种类型的变量来接收；如果不需要接收返回值：就直接调用
【2】动态开辟堆区空间

malloc  free
 #include <stdlib.h>
       void *malloc(size_t size);

功能：在堆区开辟空间
参数：size开辟空间的大小（字节）
返回值:
成功：开辟空间的首地址
失败：NULL

void free(void *ptr);
功能：释放堆区空间
参数：ptr：开辟空间的首地址
返回值：无

int * p =(int *)malloc(sizeof(int)*10);
if(p == NULL)//开辟失败
{
	printf("malloc err\n");
	return -1;
}
int i;
for(i=0;i<10;i++)
	*(p+i)=i;
free(p);
p=NULL;

如果在子函数中开辟堆区空间，主函数想要拿到开辟空间的首地址，可以有两种方法：
1.返回值：

char * fun()
{       
         char *p = NULL;
		p = (char *)malloc(32);
		strcpy(p, "hello");	
        return p;
}
int main()
{
		char *m =fun();
		printf("%s\n", m);
        free(m);
        m = NULL;
        return 0;
}

2.地址：

void fun(char **p)//p == &m
{
		*p = (char *)malloc(32);//*p == m
		strcpy(*p, "hello");	
}
int main()
{
		char *m = NULL;
		fun(&m);
		printf("%s\n", m);//hello
        free(m);
        m=NULL;
        return 0;
}

C基础day10

输入一个字符串，内有数字和非数int字符，如a123x456,将其中连续的数作为一个整数，依次存放到整形数组a中。
例：123存放在a[0],456存放在a[1]。统计共有多少整数，并输出这些整数

#include <stdio.h>
int main(int argc, char const *argv[])
{
    char buf[32] = "a123b456";
    int a[32] = {};
    char *p = buf;
    int sum = 0, i = 0, j = 0;
    while (*p)
    {
        if (*p < '0' || *p > '9')
        {
            p++;
            continue;
        }
        while (*p >= '0' && *p <= '9')
        {
            sum = sum * 10 + *p - '0';
            p++;
        }
        a[i] = sum;
        i++;
        sum = 0;
    }
    printf("整数有%d个，分别是：\n", i);
    while (j < i)
    {
        printf("%d\n", a[j]);
        j++;
    }

    return 0;
}

【1】string函数族
1.strlen
2. #include <string.h>

char *strcpy(char *dest, const char *src);

功能：实现字符串的复制
参数：dest:目标字符串的地址
src:源字符串的首地址
返回值：返回目标字符串的地址
注意：包括\0

  char *strncpy(char *dest, const char *src, size_t n);

复制字符串的前n个字符
3.#include <string.h>

  char *strcat(char *dest, const char *src);

功能：实现字符串的拼接
参数：dest:目标字符串的地址
src:源字符串的首地址
返回值：返回目标字符串的地址

 char *strncat(char *dest, const char *src, size_t n);

将源字符串的前n个字符拼接到目标字符串后面
4.#include <string.h>

      int strcmp(const char *s1, const char *s2);

功能：实现字符串的比较
参数：s1,s2:两个字符串的首地址
返回值：
比较首个字符的ASCII，如果相等就继续向后比较
1 s1 > s2
0 s1 == s2
-1 s1 < s2

     int strncmp(const char *s1, const char *s2, size_t n);

比较字符串的前n个字符

练习：
创建一个结构体数组，数组名为book，结构体成员包含编号，书名，售价（数据类型自己设定）。写一个函数，包含两个形参，分别接收结构体数组的首地址和一个指定的售价，函数的功能为打印结构体数组中售价大于指定售价的书的信息。要求：结构体数组定义在主函数中

#include<stdio.h>
#define N 3

typedef struct student
{
    int id;
    char name[32];
    float price;
}STU;

void fun(STU * p,float c)
{
    int i=0;
    while(i < N)
    {
        if(p[i].price > c)
            printf("%d %s %.2f\n",p[i].id,p[i].name,p[i].price);
        i++;
    }
}
int main(int argc, char const *argv[])
{
    STU book[N]={{1,"c",89.6},{2,"c++",99.4},{3,"java",9.9}};
    fun(book,30);
    return 0;
}

方法2：
#include<stdio.h>
#define N 3

typedef struct student
{
    int id;
    char name[32];
    float price;
}STU;

void fun(STU * p,float c)
{
    int i=0;
    while(i < N)
    {
        if((p+i)->price > c)
            printf("%d %s %.2f\n",(p+i)->id,(p+i)->name,(p+i)->price);
        i++;
    }
}
int main(int argc, char const *argv[])
{
    STU book[N]={{1,"c",89.6},{2,"c++",99.4},{3,"java",9.9}};
    fun(book,30);
    return 0;
}