c_note

字符串

字符串（字符数组）的输入输出

1. gets()遇到enter结束

   #include <string.h> //gets() 、puts()需string.h
   char ch1[20];//字符数组
   gets(ch1);
   puts(ch1);

2. scanf()遇到space/enter结束

   char ch2[20];//字符数组
   scanf("%s",ch2);
   printf("%s\n",ch2);
   fflush(stdin);//清除缓冲区(或者使用getchar()去除enter)

3. getchar()

   char ch;
   char a[256] = {0};
   while((ch=getchar())!='\n')//一直接收缓冲区的字符。直至收到回车
   {
       a[i]=ch;
       i++;
   }
   a[i]='\0';    //加上串尾符

获取字符串长度

• sizeof()

  得到指针占用的字节数 = 4

• strlen(char* s)

  在计算字符数组(char str[ ])时，一般用strlen()函数

• size()/length()

  计算字符串（string）长度，不能用char*作为参数。

  除此之外，size()函数还可以获取vector类型的长度。

printf格式输出

规定符

• %d 十进制有符号整数

• %u 十进制无符号整数

• %f 浮点数

• %s 字符串

• %c 单个字符

• %p 指针的值

• %e 指数形式的浮点数

• %x, %X 无符号以十六进制表示的整数

• %o 无符号以八进制表示的整数

• %lu 32位无符号整数

• %llu 64位无符号整数

• %% 输出百分号字符本身

其他选项

• %-10s：左对齐并占用宽度为 10 的字符串
• %5.2f：右对齐并占用宽度为 5，保留两位小数的浮点数
• %#x：输出带有 0x 前缀的十六进制数

数据类型占用字节数

image-20240704103625855

文件读写

打开文件

FILE *fopen( const char *filename, const char *mode );

filename 是字符串，用来命名文件，访问模式 mode 的值可以是下列值中的一个：

模式	描述
r	打开一个已有的文本文件，允许读取文件。
w	打开一个文本文件，允许写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会从文件的开头写入内容。如果文件存在，则该会被截断为零长度，重新写入。
a	打开一个文本文件，以追加模式写入文件。如果文件不存在，则会创建一个新文件。在这里，您的程序会在已有的文件内容中追加内容。
r+	打开一个文本文件，允许读写文件。
w+	打开一个文本文件，允许读写文件。如果文件已存在，则文件会被截断为零长度，如果文件不存在，则会创建一个新文件。
a+	打开一个文本文件，允许读写文件。如果文件不存在，则会创建一个新文件。读取会从文件的开头开始，写入则只能是追加模式。

如果处理的是二进制文件，则需使用下面的访问模式来取代上面的访问模式：

"rb", "wb", "ab", "rb+", "r+b", "wb+", "w+b", "ab+", "a+b"

关闭文件

int fclose( FILE *fp );

如果成功关闭文件，fclose( ) 函数返回零，如果关闭文件时发生错误，函数返回 EOF

写入文件

char

int fputc( int c, FILE *fp );

string

int fputs( const char *s, FILE *fp );

int fprintf(FILE *fp,const char *format, ...)

返回值：

• success =>写入的字符
• fail => EOF

example

#include <stdio.h>
 
int main()
{
   FILE *fp = NULL;
 
   fp = fopen("/tmp/test.txt", "w+");
   fprintf(fp, "This is testing for fprintf...\n");
   fputs("This is testing for fputs...\n", fp);
   fclose(fp);
}

读取文件

char

int fgetc( FILE * fp );

返回值：char转换的int

输出时，使用printf("%c", c)进行类型转换

string

char *fgets( char *buf, int n, FILE *fp );

• fgets() 从 fp 所指向的输入流中读取 n - 1 个字符。它会把读取的字符串复制到缓冲区 buf，并在最后追加一个 null 字符来终止字符串

• 停止读取：换行符 '' 或文件的末尾 EOF

int fscanf(FILE *fp, const char *format, ...) 

• 停止读取：换行符 '' 或空格

example

char buff[255];
fscanf(fp, "%s", buff);
fgets(buff, 255, (FILE*)fp);

数学函数<math.h>

pow

double pow(double x, double y): x^y

标准库<stdlib.h>

free

void free(void *ptr)

malloc

void *malloc(size_t size)

abs

int abs(int x)

fmax

double fmax(double x, double y);

fmin

double fmin(double x, double y);

qsort

void qsort(void base, size_t nitems, size_t size, int (compar)(const void *, const void *));

参数

• base: 指向待排序数组的第一个元素的指针。

• nitems: 数组中的元素数量。

• size: 数组中每个元素的大小（以字节为单位）。

• ``` compar

    : 比较函数的指针，该函数用于比较两个元素。比较函数应当返回一个整数，表示比较结果：
  
    - 小于零：表示第一个元素小于第二个元素。
    - 等于零：表示两个元素相等。
    - 大于零：表示第一个元素大于第二个元素。
  
  ```c
  int cmp (const void * a, const void * b)
  {
     return ( *(int*)a - *(int*)b );
  }
  qsort(values, 5, sizeof(int), cmp);
  
  # struct 排序
  struct node{
  	int i;
  	double j;
  	char k;
  };
  int cmp(const void *a,const void *b) {
  	return (*(node*)a).i-(*(node*)b).i;
  }

标准库<limits.h>

INT_MIN	int 类型的最小值	-2147483648
INT_MAX	int 类型的最大值	2147483647
UINT_MAX	unsigned int 类型的最大值	4294967295

常用方法<algorithm.h>

• reverse

  reverse(a, a+n);//n为数组中的元素个数
  reverse(str.begin(), str.end());//string

链表

• 必须自定义构造函数，默认构造函数无法赋值

// 单链表
struct ListNode {
    int val;  // 节点上存储的元素
    ListNode *next;  // 指向下一个节点的指针
    ListNode(int x) : val(x), next(NULL) {}  // 节点的构造函数
};

哈希表

集合	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::set	红黑树	有序	否	否	O(log n)	O(log n)
std::multiset	红黑树	有序	是	否	O(logn)	O(logn)
std::unordered_set	哈希表	无序	否	否	O(1)	O(1)

映射	底层实现	是否有序	数值是否可以重复	能否更改数值	查询效率	增删效率
std::map	红黑树	key有序	key不可重复	key不可修改	O(logn)	O(logn)
std::multimap	红黑树	key有序	key可重复	key不可修改	O(log n)	O(log n)
std::unordered_map	哈希表	key无序	key不可重复	key不可修改	O(1)	O(1)

set

• 构造函数：创建一个空的 unordered_set。

  std::unordered_set<int> uset;

• 插入元素：使用 insert() 方法。

  uset.insert(10);

• 查找元素：使用 find() 方法。

  auto it = uset.find(10);
  if (it != uset.end()) {
    // 元素存在
  }

• 删除元素：使用 erase() 方法。

  uset.erase(10);

• 大小和空检查：使用 size() 和 empty() 方法。

  size_t size = uset.size();
  bool isEmpty = uset.empty();

• 清空容器：使用 clear() 方法。

  uset.clear();

map

• 包含头文件:

  #include <map>

• 声明 map 容器:

  std::map<key_type, value_type> myMap;
  
  std::unordered_map<int, std::string> myMap = {{1, "one"}, {2, "two"}};

  • key_type 是键的类型。
  • value_type 是值的类型。

• 插入元素:

  myMap[key] = value;

• 访问元素:

  value = myMap[key];

• 遍历map:

  std::map<std::string, int> employees;
  // 遍历 map 并打印员工信息
  for (std::map<std::string, int>::iterator it = employees.begin(); it != employees.end(); ++it) {
  	std::cout << it->first << " is " << it->second << " years old." << std::endl;
  }

• 查找键find：

  auto it = myMap.find(2); // 查找键为2的元素
  if (it != myMap.end()) {
      std::cout << "Found: " << it->second << std::endl;
  }

• 删除元素：使用 erase() 方法。

  umap.erase(key);

• 大小：使用 size()。

  size_t size = umap.size();

• 清空容器：使用 clear() 方法。

  umap.clear();

堆、栈、队列

priority_queue

• 初始化

  std::priority_queue<int> pq; 默认最大堆

• empty(): 检查队列是否为空。

• size(): 返回队列中的元素数量。

• top(): 返回队列顶部的元素（不删除它）。

• push(): 向队列添加一个元素。

• pop(): 移除队列顶部的元素。

自定义优先级

struct compare {
    bool operator()(int a, int b) {
        return a > b; // 定义最小堆
    }
};
// 创建一个自定义类型的优先队列，使用最小堆
std::priority_queue<int, std::vector<int>, compare> pq_min;