C语言基础

2020-09-29

C语言输入输出

scanf() & printf()

头文件：#include<stdio.h>

1
2
3

//in: 1 2
int x = scanf("%d%d%d",&a,&b,&c);
//out: a=1,b=2,c保持不变,x=3

当扫描到文件结束符后，就自动结束输入

x为正确接收到值的变量个数。当scanf函数的第一个变量格式不正确时返回值为0，即，当scanf函数的第n个变量格式不正确时，返回值为n-1；当scanf在扫描到了合法字符之前扫描到了输入结束符，则返回-1。

输入浮点数

double f;
scanf("%lf",&f);

float f2;
scanf("%f",&f2);

上面的lf格式对应double数据类型，f格式对应float数据类型。

输入16进制数

//int: A
int a;
scanf("%X",&a);
printf("%d",a);
//out: 10

输入多个单词

1
2
3

while(scanf("%d",&a) > 0){
    printf("%d\n",a);
}

输出填充字符

int main()
{
    //%0xld:要是输出小于x位，用0补上，使输出达到x位；否则正常输出。
    printf("%02ld\n",1);
    printf("%02ld\n",111);

    printf("------\n"); 
    //%xld:要是输出小于x位，用空格补上，使输出达到x位；否则正常输出。
    printf("%2ld\n",1);
    printf("%2ld\n",111);
}

getchar() & putchar()

头文件：#include<stdio.h>

函数 int getchar(void) 函数读取下一个可用的字符，若到达了文件的结尾，则返回-1。

#include<stdio.h>
int main(){
    int c = getchar();
}

int putchar(void) 函数在同一个时间把一个字符输出到屏幕上。

fgets()和cin.get()

头文件：#include<stdio.h>

函数 char *fgets(char *str, int n, FILE* stream) 从指定的流 stream 读取一行，并把它存储在 str 所指向的字符串内。当读取 (n-1) 个字符时，或者读取到换行符时，或者到达文件末尾时，它会停止。

#include <stdio.h>
char *fgets(char *s, int size, FILE *stream); //size是自定义读入字符的最大个数，包括\0
//如果size=5，而输入是abc\n，则缓冲区中为abc\n\0
//如果size=4，而输入是abc\n，则缓冲区中为abc\0
//如果size=3，而输入为abc\n，则缓冲区为ab\0

//输入
const in MAXNUM = 105;
char str[MAXNUM];
cin >> str; // 遇到空白字符停止

fgets(str, MAXNUM, stdin); // 可以把换行符也输入进来
                           // MAXNUM参数表示最多只能输入多少个字符,包括\0
                           // 在没有达到MAXNUM个，且遇到了回车符，就停止输入，同时也把回车符加入到str中

cin.get(str, MAXNUM); // 默认遇到换行符停止

// 输出
cout<<str<<endl;

puts(str); // 默认在结尾输出换行

cin.ignore()

cin.ignore()函数是C++标准输入流（cin）中的一个方法。cin.ignore()函数中有两个参数，分别为数值型的a 和字符型的 ch ，即cin.ignore( a, ch )。它表示从输入流 cin 中提取字符，提取的字符被忽略，不被使用。而每抛弃一个字符，它都要进行计数和比较字符：如果计数值达到 a 或者被抛弃的字符是 ch ，则cin.ignore() 函数执行终止；否则，它继续等待。

它的一个常用功能就是用来清除以回车结束的输入缓冲区的内容，消除上一次输入对下一次输入的影响。例如可以这么用，cin.ignore(1024, ‘\n’)，通常把第一个参数设置得足够大，这样实际上是为了只有第二个参数 ‘\n’ 起作用，所以这一句就是把回车（包括回车）之前的所以字符从输入缓冲流中清除出去。

1	cin.ignore(INT_MAX, '\n');

例子：

#include<iostream>
#include<climits>
using namespace std;
#define MAXN 10005
int main(){
    char a[MAXN], b;
    cin.sync_with_stdio(false); // 增加输入输出的速度
	cin.get(a, MAXN);
    cin.ignore(INT_MAX, '\n'); 
    cin>>b;
    cout<<a<<","<<b<<endl;
    return 0;
}
// 输入：
// 1234567890
// fight
// 输出：
// ?

getline()

需要额外引入string包。

只能用来给string类型输入字符串。

不把分隔符读入string中，同时把分隔符从缓冲区中移出。

#include<iostream>
#include<climits>
#include<string>
using namespace std;
#define MAXN 10005
int main(){
	string a;
    char b;
    cin.sync_with_stdio(false); // 增加输入输出的速度
    // cin.ignore(INT_MAX, '\n'); 
    cin>>b;
    cout<<a<<","<<b<<endl;
    return 0;
}

sscanf() & sprintf()

1 2	char str[] = "123" sscanf(str,"%d",&a);

从字符串中读入数组。由此看来，sscanf()和scanf()有很多相似之处。

1
2
3

double a = 12.123;
char str[20];
sprintf(str,"%.3lf",a);

将数字输出到字符串中。

C语言字符串

头文件：#include<string.h>

C语言字符串操作要保证给字符串开足够大的空间。

strcpy()

1
2
3

char s1[10];
char s2[10];
strcpy(s1,s2); //复制字符串s2到s1

strcat()

1
2
3

char s1[10];
char s2[10];
strcat(s1,s2); //连接字符串s2到s1的末尾

strlen()

1	strlen(s1); //返回s1的长度

strcmp()

1 2	strcmp(s1,s2); //如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回小于 0；如果 s1>s2 则返回大于 0。

strchr()

返回字符首次出现的指针位置。

char s1[10] = "123";
int pos =0 ;
strchr(s1+pos,'1')-s1; 
//从s1的pos位置开始查找，找到第一个'1'字符的位置。out: 0

可以通过strchr()函数实现C++中string对象的find()函数的操作。

strncpy()

函数格式：char *strncpy(char *dest, const char *src, size_t n)

n：要从源中复制的字符数

#include <stdio.h>
#include <string.h>
 
int main()
{
   char src[40];
   char dest[12];
  
   memset(dest, '\0', sizeof(dest));
   strcpy(src, "This is runoob.com");
   strncpy(dest, src, 10);
 
   printf("最终的目标字符串： %s\n", dest);
   
   return(0);
}
//out: 最终的目标字符串： This is ru

注意：strncpy不会在最后加上\0结束符。

指针

void*指针

在使用C语言进行开发的过程中，经常会遇到void*这样一个特殊的指针。

下面是void *指针的使用场景。

用作泛型，接收任意数据类型指针

void*用于指向特定地址，而无需关心这个地址上存放着什么类型的数据。例如常见的memcpy等函数就用到void*，函数原型如下:

1	void memcpy(void des, void *src, size_t n);

此处的void des和void src可以接收任意类型的数据类型指针，既然是内存拷贝，入参就不应该限制传入什么类型的指针，逻辑上十分合理。

动态内存申请与释放

动态内存申请函数返回值一般都是void*，如果申请成功则返回的是申请的内存块的首地址，申请失败则返回一个空指针NULL，NULL相当于（void *）0。C库的malloc函数原型如下：

1	void *malloc(size_t size);

一般申请完内存之后会与指针类型强制转换一起使用，如下所示。

typedef struct 
{
    char    *name;
    int     age;
    ...
}animal, *animal_t;
 
animal_t dog = (animal_t )malloc(sizeof(animal));
if(!dog)
{
    printf("malloc failed\n");
}

函数指针

如果在程序中定义了一个函数，那么在编译时系统就会为这个函数代码分配一段存储空间，这段存储空间的首地址称为这个函数的地址。而且函数名表示的就是这个地址。既然是地址我们就可以定义一个指针变量来存放，这个指针变量就叫作函数指针变量，简称函数指针。

定义一个指向函数的指针变量 p，p的类型是int(*)(int，int):

1	int(*p)(int, int);

例子：

# include <stdio.h>
int Max(int, int);  //函数声明
int main(void)
{
    int(*p)(int, int);  //定义一个函数指针
    int a, b, c;
    p = Max;  //把函数Max赋给指针变量p, 使p指向Max函数
    printf("please enter a and b:");
    scanf("%d%d", &a, &b);
    c = (*p)(a, b);  //通过函数指针调用Max函数
    printf("a = %d\nb = %d\nmax = %d\n", a, b, c);
    return 0;
}
int Max(int x, int y)  //定义Max函数
{
    int z;
    if (x > y)
    {
        z = x;
    }
    else
    {
        z = y;
    }
    return z;
}

输出：

please enter a and b:3 4
a = 3
b = 4
max = 4

指向函数的指针变量没有 ++ 和 — 运算

预处理语句

ifndef

在.h文件中，经常会看到这样的代码：

// a.h
#ifdef __A_H_
#define __A_H_

// your declaration

#endif

假如：

1 2	// b.h #include "a.h"

1
2
3

// c.c
#include "a.h"
#include "b.h"

当我们编译a.h，a.c，b.h，b.c, c.c时，如果没有a.h文件中的预处理语句ifndef，那么a.h中的代码就会出现两次，导致重复声明；当有了ifndef预处理语句时：包含a.h会使得__A_H_常量被定义并且将它的代码包含再c.c中，然后再包含b.h时由于__A_H_时，就由于__A_H_被定义，所以不会再包含重复的代码了。