类型
函数名( 形式参数 )
代码块

function_name()
{

}

int *
find_int(key, array, array_len)
int key;
int array[];
int array_len;
{}

#ifndef COUNTER_H
#define COUNTER_H

// Increment the counter by 1.
void increment_counter(void);

// Get the current value of the counter. 
int get_counter(void);
#endif // COUNTER_H

#include "counter.h"
#include <stdio.h>
// This is a static variable. Its value is kept for the lifetime of the program,
// but it is only visible and accessible within this file (counter.c).
static int count = 0;

// This is a static function. It's a private helper and cannot be called
// from outside this file.
static void private_helper()
{
  printf("--- (Internal) The counter is now being updated... ---\n");
}

// Public API function. It calls the private helper function
void increment_counter()
{
  private_helper(); // This is allowed bacause private_helper is in the same file.
  count++;
}

// Public API function. It returns the value of the private variable.
int get_counter()
{
  return count;
}

#include <stdio.h>
#include "counter.h"

int main()
{
  printf("Initial counter value: %d\n",get_counter());
  
  // Call the public function to increment the counter.
  increment_counter();
  printf("Counter value after first increment: %d\n", get_counter());

  increment_counter();
  printf("Counter value after second increment: %d\n", get_counter());

  // COMPILE/LINK ERROR!
  // The linker will fail because private_helper() is not a public symbol.
  // private_helper(); 

  return 0; 
}

factorial(n) =
├── n <= 0 : 1
└── n > 0 : n x factorial(n - 1)

long 
factorial(int n)
{
  if (n <= 0)
    return 1;
  else 
    return n * factorial(n - 1);
}

long
factorial(int n)
{
  int result = 1;
  while (n > 1)
  { 
    result *= n;
    n -= 1;
  }
  
  return result;
}

Fibonacci(n) =
├── n <= 1 : 1 
├── n = 2 : 1
├── n > 2 : Fibonacci(n - 1) +Fibonacci(n - 2)

long fibonacci(int n)
{
  if (n <= 2)
    return 1;

  return fibonacci(n - 1) + fibonacci(n - 2);
}

long fibonacci(int n)
{
  long result;
  long previous_result;
  long next_older_result;
  
  result = previout_result = 1;
  
  if (n <= 2)
    return 1;
  
  while (n > 2)
  {
    n -= 1;
    next_older_result = previous_result;
    previous_result = result;
    result = previous_result + next_older_result;
  }
}

float average(int n_values, int v1,int v2, int v3, int v4, int v5)
{
  float sum = v1; 
  
  if ( n_values >= 2)
    sum += v2;
  if ( n_values >= 3 )
    sum += v3;
  if ( n_values >= 4 )
    sum += v4;
  if ( n_values >= 5 )
    sum += v5;

  return sum / n_values;
}

#include <stdarg.h>

float average(int n_values, ...) // 传递任意数量的未知数
{
  va_list var_arg;
  int count;
  float sum;
  
  // 准备访问可变参数
  va_start (var_arg, n_values);
  
  // 添加取自可变参数列表的值
  for (count = 0;count < n_values;count += 1)
    sum += va_arg(var_arg, int);
  
  // 完成处理可变参数
  va_end(var_arg);
  
  return sum / n_values;
}

int a;
int b[10];

array[subscript] == *(array + (subscript))

int array[10];
int *ap = array + 2;

int array[10],a;
for (a = 0;a < 10;a++)
  array[a] = 0;

int array[10],*ap;
for (ap = array;ap < array + 10;ap++)
  *ap = 0;

#define SIZE 50
int x[SIZE];
int y[SIZE];
int i;
int *p1,*p2;

void try1()
{
  for(i = 0; i < SIZE;i++)
    x[i] = y[i];
}

void try2()
{
    for( p1 = x, p2 = y; p1 - x < SIZE;)
      *p1++ = *p2++;
}

void try3()
{
  for( i = 0; p1 = x, p2 = y; i < SIZE; i++)
  {
    *p1++ = *p2++;
  }
}

void try4()
{
  register int *p1, *p2;
  register int i;
  
  for( i = 0;p1 = x, p2 = y;i < SIZE; i++)
    *p1++ = *p2++;
}

void try5()
{
  register int *p1, *p2;

  for( p1 = x, p2 = y;p1 < &x[SIZE])
  {
    *p1++ = *p2++;
  }
}

void strcpy(char *buffer, char const *string)
{
  while (*buffer++ = *string++ != '\0');
}

int   vector[10], *vp = vector;
int   matrix[3][10], *mp = matrix;

int *pi = &matrix[0][0];
int *pi = matrix[0];

void func2(int (*mat)[10]);
void func2(int mat[][10]);

int matrix[2][3] = {100,101,102,110,111,112};

int two_dim[3][5] = {
  {00,01,02,03,04},
  {00,01,02,03,04},
  {00,01,02,03,04}
};

char const *keyword[] = {
    "do",
    "for",
    "register",
    "return",
    "switch",
    "while",
    NULL 
};
#define N_KEYWORD \
  (sizeof(keyword) / sizeof(keyword[0]))

# 判断参数是否与一个关键字列表中的任何单词匹配，并返回匹配的索引值。
# 如果未找到匹配函数返回-1
#include <string.h>

int lookup_keyword( char const* const desired_word, 
              char const *keyword_table[], int const size)
{
  char const **kwp;
  
  // 对于表中的每个单词 ...
  // for (kwp = keyword_table; kwp < keyword_table + size; kwp++)
  // {
  //   if (strcmp(desired_word, *kwp) == 0)
  //       return kwp - keyword_table;
  // }
  for (kwp = keyword_table; kwp != NULL;kwp++)
  {
    if (strcmp(desired_word, *kwp) == 0)
      return kwp - keyword_table;
  }
  

  // 没有找到
  return -1;
}

strlen 原型
size_t strlen (char const *string);

if (strlen(x) >= strlen(y)) ...
if (strlen(x) - strlen(y) >= 0) ...

#include <stddef.h>

size_t 
strlen(char const *string)
{
  int length;
  
  for (length = 0; *string++ != '\0';)
    length += 1;
  return length;
}

if (strlen(x) >= 10) ...
if (strlen(x) - 10 >= 0) ...

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

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

strcpy( message, "Hello ");
strcat( message, customer_name );
strcpy( message, ", how are you?");

strcat(strcpy(dst,a),b);

strcpy(dst,a);
strcat(dst,b);

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

if (strcmp(a,b)) // 用于布尔值测试是一种坏风格
if (strcmp(a,b) > 0) // 用于与零进行比较更好
else if (strcmp(a,b) < 0)
else

char *strncpy(char *dst, char const *src, size_t len);
char *strncat(char *dst, char const *src, size_t len);
char *strncmp(char const *s1, char const *s2, size_t len);

char buffer[BSIZE];
...
strncpy(buffer, name, BSIZE);
buffer[BSIZE - 1] = '\0';

char *strchr(char const *str, int ch);
char *strrchr(char const *str, int ch);

char string[20] = "Hello there, honey.";
char *ans;
ans = strchr(string, 'h');

char *strpbrk(char const *str, char const *group);

char string[20] = "Hello there, honey.";
char *ans;
ans = strchr(string, "aeiou");

char *strstr(char const *s1, char const *s2);

#include <string.h>

char*
my_strrstr(char const *s1, char const *s2)
{
  register char *last;
  register char *current;

  // 把指针初始化为我们已经找到的前一次匹配
  last = NULL;
  
  // 只在第二个字符串不为空的时候进行查找，如果s2为空返回NULL
  
  if (*s2 != '\0')
  {
    // 查找 s2 在 s1 中第一次出现的位置。
    current = strstr(s1,s2);
    while (current != NULL)
    {
      last = current;
      current = strstr(last + 1, s2);
    }
  }
  return last; // 返回指向我们找到的最后一次匹配的起始位置的指针。
}

#include <string.h>

char *
my_strrpbrk(char const *str, char const *group)
{
  register char *last;
  register char current;
  
  // 把指针初始化为我们已经找到的前一次匹配
  last = NULL;
  
  if (*s2 != '\0')
  {
    current = strpbrk(str, group);
    while (current != NULL)
    {
      last = current;
      current = strpbrk(last + 1, group);
    }
  }
  return last;
}

size_t strspn(char const *str, char const *group);
size_t strcspn(char const *str, char const *group);

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

int main() {
    const char *sentence = "Hello, world!";
    const char *charset_vowels = "aeiou";
    const char *charset_alpha = "abcdefghijklmnopqrstuvwxyz";

    size_t length1 = strspn(sentence, "Heo");
    printf("The length of the initial part of \"%s\" consisting of 'H', 'e', 'o' is: %zu\n", sentence, length1); 
    // 输出: 2 (因为 'l' 不在 "Heo" 中)

    size_t length2 = strspn(sentence, charset_alpha);
    printf("The length of the initial part of \"%s\" consisting of letters is: %zu\n", sentence, length2);
    // 输出: 5 (因为 ' ' 不在字母表中)

    return 0;
}

char *strtok(char *str, char const *sep);

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

int main(void)
{
  char str[] = "apple,banana-orange";
  const char *delimiters = ",-";
  char *token;

  // 第一次调用， 传入字符串
  token = strtok(str,delimiters);
  printf("First token: %s\n", token);
  
  // 后续调用，传入NULL
  while(token != NULL)
  {
    token = strtok(NULL,delimiters);
    if (token != NULL){
      printf("Next token: %s\n",token);
    }
  }
  return 0;
}

char *stderror(int error_number);

#include <stdio.h>
#include <string.h>
#include <errno.h>
// 必须包含此头文件来使用 errno

int main(void)
{
  FILE *file;
  // 尝试打开一个不存在的文件
  file = fopen("non_existent_file.txt", "r");
  
  // 如果 fopen 失败
  if (file == NULL)
    printf("Error opening file: %s\n", strerror(errno));
  else
  {
    printf("File opened successfully.\n");
    fclose(file);
  }
  return 0;
}

int tolower(int ch);
int toupper(int ch);

if (ch >= 'A' && ch <= 'Z') 在ASCII字符集的机器上能够运行，但是其他字符集有可能会失败
if (isupper(ch))
就都能顺利运行

void *memcpy(void *dst, void const *src, size_t length);
void *memmove(void *dst, void const *src, size_t length);
void *memcmp(void const *a, void const *b, size_t length);
void *memchr(void const *a, int ch, size_t length);
void *memset(void *a, int ch, size_t length);

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

int main(void)
{
  int source_array[] = {1,2,3,4,5};
  int destinaion_array[5];
  
  // copy 5 integers from soure_array to destination_array
  memcpy(destination_array, source_array, sizeof(source_array));

  printf("Destinaion array: ");
  for (int i = 0; i < 5; i++)
  {
    printf("%d ",destination_array[i]);
  }
  printf("\n");
  return 0;
}

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

int main(void)
{
  char str[] = "abcdefgh";
  
  // Shift the string two characters to the left
  // The source and destination overlap (str + 2 and str)
  memmove(str, str + 2,strlen(str) - 2);
  
  // manually add the null terminator since memmove doesn't
  str[strlen(str) - 2] = '\0';
  printf("String after memmove: %s\n", str); // prints "cdefgh"

  return 0;

}

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

int main(void) {
  // This array contains a null byte in the middle.
  char data[] = {'h', 'e', 'l', 'l', 'o', '\0', 'w', 'o', 'r', 'l', 'd'};
  char *result;
- 
  // Search for the character 'o' within the first 11 bytes of the array.
  // A string search function like strchr would stop at the '\0'
  result = memchr(data, 'o', sizeof(data));
  if (result != NULL) {
    printf("Found 'o' at memory address: %p\n", result);
    printf("Character found: '%c'\n", *result);

    // Calculate the index of the found character
    size_t index = (size_t)(result - data);
    printf("It is located at index: %zu\n", index);
  } else {
    printf("The character was not found.\n");
  }
  return 0;
}

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

int main(void)
{
  char data1[] = "Hello";
  char data2[] = "HellO";
  char data3[] = "Hello";
  
  // compare the first 5 bytes of data1 and data2
  int result1 = memcmp(data1, data2, 5);
  if (result1 != 0)
  {
    printf("data1 and data2 are different.\n");
  }
  // compare the first 5 bytes of data1 and data2
  
  int result2 = memcmp(data1, data3, 5);
  if(result2 != 0)
  {
    printf("data1 and data3 are different.\n");
  }
  return 0;
}

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

int main(void)
{
  char buffer[10];
  
  // Initialize all 10 bytes of the buffer to 'A'
  memset(buffer, 'A', sizeof(buffer));
  printf("Buffer after memset: %.10s\n",buffer);
  
  // Initialize the buffer to all zeros (a common and safe practice)
  memset(buffer, 0, sizeof(buffer));
  printf("Buffer after zeroing: %d\n", buffer[0]); // Prints 0

  return 0;
}