C语言基础

#include <stdio.h> // 头文件：引入标准输入输出库---就像准备PPT课件，没课件没法上课
// int main() 程序入口，就相当于上课铃响了
// 大括号{}里的代码，就像上课过程
int main () {

printf("Hello\n"); // 输出一句话 Hello， \n相当于讲完一个知识点，翻页了

return 0; // 返回0：表示成功结束，交给操作系统
}

const int MAX = 100;  // 整型常量
const float PI = 3.14;  // 浮点型常量
const char NEWLINE = '\n';  // 字符常量

char greeting[] = "Hello, World!";

enum color {RED, GREEN=5, BLUE};   // RED=0, GREEN=5, BLUE=6
enum color c = RED;                // 等价于 int c = 0;

double d = 3;     // int 3 被悄悄扩成 double 3.0
int    a = 3.7;   // double 3.7 被截成 int 3，小数直接消失

int    x = 10;
double y = (double)x / 4;   // 把 x 先强转成 double，再做除法得 2.5

void  *p = malloc(16); // 向堆管理器申请 16 字节的连续内存，成功返回首地址
// 返回类型是 void *，意思是"我手里有一块内存，但还没决定把它当什么类型用"
int   *q = (int *)p;        // void* → int* 必须显式转（C++ 必需，C 可选）
// (int *)p 是显式类型转换，把"无类型地址"强制解释成"指向 int 的地址"

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

{
   int mount;
   auto int month;
}

{
   register int  miles;
}

#include <stdio.h>
 
int count ;
extern void write_extern();
 
int main()
{
   count = 5;
   write_extern();
}

#include <stdio.h>
 
extern int count;
 
void write_extern(void)
{
   printf("count is %d\n", count);
}

int num;
(num%2==0)?printf("偶数"):printf("奇数");

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int a = 10;
   /* while 循环执行 */
   while( a < 20 )
   {
      printf("a 的值： %d\n", a);
      a++;
   }
   return 0;
}

#include <stdio.h>
 
int main ()
{
   /* for 循环执行 */
   for( int a = 10; a < 20; a = a + 1 )
   {
      printf("a 的值： %d\n", a);
   }
   return 0;
}

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int a = 10;
   /* do 循环执行，在条件被测试之前至少执行一次 */
   do
   {
       printf("a 的值： %d\n", a);
       a = a + 1;
   }while( a < 20 );
   return 0;
}

#include <stdio.h>
 
int main ()
{
   /* 局部变量定义 */
   int i, j;
   for(i=2; i<100; i++) {
      for(j=2; j <= (i/j); j++)
        if(!(i%j)) break; // 如果找到，则不是质数
      if(j > (i/j)) printf("%d 是质数\n", i);
   }
   return 0;
}

#include <stdio.h>
int main()
{
    int i=1,j;
    do
    {
        j=1;
        do
        {
            printf("*");
            j++;
        }while(j <= i);
        i++;
        printf("\n");
    }while(i <= 5);
    return 0;
}

#include <stdio.h>
 
/* 函数声明 */
int max(int num1, int num2);
 
int main ()
{
   /* 局部变量定义 */
   int a = 100;
   int b = 200;
   int ret;
 
   /* 调用函数来获取最大值 */
   ret = max(a, b);
 
   printf( "Max value is : %d\n", ret );
 
   return 0;
}
 
/* 函数返回两个数中较大的那个数 */
int max(int num1, int num2) 
{
   /* 局部变量声明 */
   int result;
 
   if (num1 > num2)
      result = num1;
   else
      result = num2;
 
   return result; 
}

/* 函数定义 */
void swap(int x, int y)
{
   int temp;

   temp = x; /* 保存 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 temp 赋值给 y */
  
   return;
}

#include <stdio.h>
 
/* 函数声明 */
void swap(int x, int y);
 
int main ()
{
   /* 局部变量定义 */
   int a = 100;
   int b = 200;
   printf("交换前，a 的值： %d\n", a );
   printf("交换前，b 的值： %d\n", b );
   /* 调用函数来交换值 */
   swap(a, b);
   printf("交换后，a 的值： %d\n", a );
   printf("交换后，b 的值： %d\n", b );
   return 0;
}

/* 函数定义 */
void swap(int *x, int *y)
{
   int temp;
   temp = *x;    /* 保存地址 x 的值 */
   *x = *y;      /* 把 y 赋值给 x */
   *y = temp;    /* 把 temp 赋值给 y */
  
   return;
}

#include <stdio.h>
 
/* 函数声明 */
void swap(int *x, int *y);
 
int main ()
{
   /* 局部变量定义 */
   int a = 100;
   int b = 200;
 
   printf("交换前，a 的值： %d\n", a );
   printf("交换前，b 的值： %d\n", b );
 
   /* 调用函数来交换值
    * &a 表示指向 a 的指针，即变量 a 的地址 
    * &b 表示指向 b 的指针，即变量 b 的地址 
   */
   swap(&a, &b);
 
   printf("交换后，a 的值： %d\n", a );
   printf("交换后，b 的值： %d\n", b );
 
   return 0;
}

#include <stdio.h>
 
/* 全局变量声明 */
int g;

int main ()
{
  /* 局部变量声明 */
  int a, b;
 
  /* 实际初始化 */
  a = 10;
  b = 20;
  g = a + b;
 
  printf ("value of a = %d, b = %d and g = %d\n", a, b, g);
  return 0;
}

double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

balance[4] = 50.0;

enum　枚举名　{枚举元素1,枚举元素2,……};

#include <stdio.h>
 
enum DAY
{
      MON=1, TUE, WED, THU, FRI, SAT, SUN
};

int main()
{
    enum DAY day;
    day = WED;
    printf("%d",day);
    return 0;
}

char *img;
const char *p1, *p2; // ✅ p1、p2都是“指向const char的指针”

#include <stdio.h>

int main() {

    int var = 10;

    int *p = &var;    // p指向var

    int **pp = &p;    // pp指向p（指针的指针）

    printf("var的地址：%p\n", &var);   // var的地址

    printf("p存储的地址：%p\n", p);    // var的地址

    printf("p自身的地址：%p\n", &p);   // p的地址

    printf("pp存储的地址：%p\n", pp);  // p的地址

    printf("pp自身的地址：%p\n", &pp); // pp的地址

    printf("通过pp获取var的值：%d\n", **pp); // 解引用两次，得到10

    return 0;

}

#include <stdio.h>
 
int main ()
{
    int var_runoob = 10;
    int *p;              // 定义指针变量
    p = &var_runoob;
 
   printf("var_runoob 变量的地址： %p\n", p);
   return 0;
}

type *var_name;

int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */

#include <stdio.h>
 
int main ()
{
   int  var = 20;   /* 实际变量的声明 */
   int  *ip;        /* 指针变量的声明 */
 
   ip = &var;  /* 在指针变量中存储 var 的地址 */
 
   printf("var 变量的地址: %p\n", &var  );
 
   /* 在指针变量中存储的地址 */
   printf("ip 变量存储的地址: %p\n", ip );
 
   /* 使用指针访问值 */
   printf("*ip 变量的值: %d\n", *ip );
 
   return 0;
}```

当上面的代码被编译和执行时，它会产生下列结果：

> var 变量的地址: 0x7ffeeef168d8
> ip 变量存储的地址: 0x7ffeeef168d8
> *ip 变量的值: 20

**C 中的 NULL 指针**

在变量声明的时候，如果没有确切的地址可以赋值，为指针变量赋一个 NULL 值是一个良好的编程习惯。赋为 NULL 值的指针被称为**空**指针。

NULL 指针是一个定义在标准库中的值为零的常量。请看下面的程序：

```c
#include <stdio.h>
 
int main ()
{
   int  *ptr = NULL;
 
   printf("ptr 的地址是 %p\n", ptr  );
 
   return 0;
}

if(ptr)     /* 如果 p 非空，则完成 */
if(!ptr)    /* 如果 p 为空，则完成 */

#include <stdio.h>
 
int max(int x, int y)
{
    return x > y ? x : y;
}
 
int main(void)
{
    /* p 是函数指针 */
    int (* p)(int, int) = & max; // &可以省略
    int a, b, c, d;
 
    printf("请输入三个数字:");
    scanf("%d %d %d", & a, & b, & c);
 
    /* 与直接调用函数等价，d = max(max(a, b), c) */
    d = p(p(a, b), c); 
 
    printf("最大的数字是: %d\n", d);
 
    return 0;
}

#include <stdlib.h>  
#include <stdio.h>
 
void populate_array(int *array, size_t arraySize, int (*getNextValue)(void))
{
    for (size_t i=0; i<arraySize; i++)
        array[i] = getNextValue();
}
 
// 获取随机值
int getNextRandomValue(void)
{
    return rand();
}
 
int main(void)
{
    int myarray[10];
    /* getNextRandomValue 不能加括号，否则无法编译，因为加上括号之后相当于传入此参数时传入了 int , 而不是函数指针*/
    populate_array(myarray, 10, getNextRandomValue);
    for(int i = 0; i < 10; i++) {
        printf("%d ", myarray[i]);
    }
    printf("\n");
    return 0;
}

16807 282475249 1622650073 984943658 1144108930 470211272 101027544 1457850878 1458777923 2007237709 

#include <stdio.h>
#include <string.h>
 
int main ()
{
   char str1[14] = "runoob";
   char str2[14] = "google";
   char str3[14];
   int  len ;
 
   /* 复制 str1 到 str3 */
   strcpy(str3, str1);
   printf("strcpy( str3, str1) :  %s\n", str3 );
 
   /* 连接 str1 和 str2 */
   strcat( str1, str2);
   printf("strcat( str1, str2):   %s\n", str1 );
 
   /* 连接后，str1 的总长度 */
   len = strlen(str1);
   printf("strlen(str1) :  %d\n", len );
 
   return 0;
}

struct tag { 
    member-list
    member-list 
    member-list  
    ...
} variable-list ;

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};
 
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 输出 Book1 信息 */
   printf( "Book 1 title : %s\n", Book1.title);
   printf( "Book 1 author : %s\n", Book1.author);
   printf( "Book 1 subject : %s\n", Book1.subject);
   printf( "Book 1 book_id : %d\n", Book1.book_id);

   /* 输出 Book2 信息 */
   printf( "Book 2 title : %s\n", Book2.title);
   printf( "Book 2 author : %s\n", Book2.author);
   printf( "Book 2 subject : %s\n", Book2.subject);
   printf( "Book 2 book_id : %d\n", Book2.book_id);

   return 0;
}

#include <stdio.h>
#include <string.h>
 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

/* 函数声明 */
void printBook( struct Books *book );
int main( )
{
   struct Books Book1;        /* 声明 Book1，类型为 Books */
   struct Books Book2;        /* 声明 Book2，类型为 Books */
 
   /* Book1 详述 */
   strcpy( Book1.title, "C Programming");
   strcpy( Book1.author, "Nuha Ali"); 
   strcpy( Book1.subject, "C Programming Tutorial");
   Book1.book_id = 6495407;

   /* Book2 详述 */
   strcpy( Book2.title, "Telecom Billing");
   strcpy( Book2.author, "Zara Ali");
   strcpy( Book2.subject, "Telecom Billing Tutorial");
   Book2.book_id = 6495700;
 
   /* 通过传 Book1 的地址来输出 Book1 信息 */
   printBook( &Book1 );

   /* 通过传 Book2 的地址来输出 Book2 信息 */
   printBook( &Book2 );

   return 0;
}
void printBook( struct Books *book )
{
   printf( "Book title : %s\n", book->title);
   printf( "Book author : %s\n", book->author);
   printf( "Book subject : %s\n", book->subject);
   printf( "Book book_id : %d\n", book->book_id);
}

union [union tag]
{
   member definition;
   member definition;
   ...
   member definition;
} [one or more union variables];

union Data
{
   int i;
   float f;
   char  str[20];
} data;

#include <stdio.h>
#include <string.h>
 
union Data
{
   int i;
   float f;
   char  str[20];
};
 
int main( )
{
   union Data data;        
 
   printf( "Memory size occupied by data : %d\n", sizeof(data));
 
   return 0;
}

#include <stdio.h>
#include <string.h>
 
union Data
{
   int i;
   float f;
   char  str[20];
};
 
int main( )
{
   union Data data;        
 
   data.i = 10;
   data.f = 220.5;
   strcpy( data.str, "C Programming");
 
   printf( "data.i : %d\n", data.i);
   printf( "data.f : %f\n", data.f);
   printf( "data.str : %s\n", data.str);
 
   return 0;
}

#include <stdio.h>
#include <string.h>
 
union Data
{
   int i;
   float f;
   char  str[20];
};
 
int main( )
{
   union Data data;        
 
   data.i = 10;
   printf( "data.i : %d\n", data.i);
   
   data.f = 220.5;
   printf( "data.f : %f\n", data.f);
   
   strcpy( data.str, "C Programming");
   printf( "data.str : %s\n", data.str);
 
   return 0;
}

struct 名字 {
    类型 成员名 : 位数;
    ...
};

#include <stdio.h>
typedef struct {
    unsigned int year : 12;   // 0~4095
    unsigned int mon  : 4;    // 1~12
    unsigned int day  : 5;    // 1~31
} Date;

int main(void){
    Date d = {2025, 12, 20};
    printf("size = %zu 字节\n", sizeof(d));     // → 4
    printf("0x%08X\n", *(unsigned int*)&d);     // → 0x07E94C14
}

bit31~bit0  
....---- year(12) ----| mon(4) | day(5)
0x07E94C14 二进制
0000 0111 1110 1001 0100 1100 0001 0100
└----year=2025---┘└m┘└-day=20-┘

typedef 原类型 新名字;

typedef unsigned long long uint64;  // 以后写 uint64 即可
uint64 a = 123;

typedef struct Node {          // 同时给匿名结构体起了两个名字
    int data;
    struct Node *next;
} Node, *pNode;                // Node = 结构体本身，pNode = 结构体指针
Node head;                     // 不用再写 struct Node head;
pNode p = &head;               // 等价于 struct Node *

typedef double vec3[3];        // vec3 是“含 3 个 double 的数组类型”
vec3 v1 = {1,2,3};             // 定义数组对象
sizeof(v1);                    // 24 字节

// 原声
int (*fp)(double, char);       // 声明变量 fp
// typedef 版
typedef int (*Func)(double, char);
Func fp;                       // 同样声明变量 fp
fp = printf;                   // 合法，因为 printf 原型兼容

typedef int (*ArrayPtr)[5];    // ArrayPtr 是“指向含 5 个 int 的数组”的指针
int a[5];
ArrayPtr ap = &a;              // ap 指向整个数组

typedef unsigned int size_t;   // 32 位平台
typedef unsigned long size_t;  // 64 位平台

原类型 --------------------→ 新名字（外号）
     ↑                            ↓
编译器内部仍用原类型         源码里你可以写得更短/更易读

#include <stdio.h>
 
int main()
{
   int sum = 17, count = 5;
   double mean;
 
   mean = (double) sum / count;
   printf("Value of mean : %f\n", mean );
 
}

#include <stdio.h>
FILE *fp = fopen("路径", "模式");
if (!fp) { perror("fopen"); exit(EXIT_FAILURE); }
...
fclose(fp);

/* 写 */
fprintf(fp, "%d %.2f %s\n", 42, 3.14, "hello");

/* 读 */
int   n;
float x;
char  s[32];
fscanf(fp, "%d%f%s", &n, &x, s);   // 返回值==3 表示成功读到 3 个域

typedef struct { int id; float score; } Rec;

/* 写一条记录 */
Rec r = {1, 95.5};
fwrite(&r, sizeof(r), 1, fp);      // 返回 1 表示成功写 1 个对象

/* 读回来 */
Rec tmp;
rewind(fp);                        // 回到文件头
size_t n = fread(&tmp, sizeof(tmp), 1, fp);
if (n == 1) printf("%d %.1f\n", tmp.id, tmp.score);

/* 把文件全部读进动态缓冲区 */
FILE *fp = fopen("big.txt", "rb");
fseek(fp, 0, SEEK_END);
long sz = ftell(fp);
rewind(fp);
char *buf = malloc(sz+1);
fread(buf, 1, sz, fp);
buf[sz] = 0;          // 字符串结尾
fclose(fp);
/* 现在 buf 就是整个文件内容 */

int fseek(FILE *stream, long offset, int whence);
long ftell(FILE *stream);
void rewind(FILE *stream);

#define RECSZ 32
fseek(fp, 2*RECSZ, SEEK_SET);
fwrite(&newRec, RECSZ, 1, fp);

int fflush(FILE *fp);        // 把用户缓冲区刷进内核
int ferror(FILE *fp);        // 返回非 0 表示之前出现过错误
void clearerr(FILE *fp);     // 清除错误标志

#include <stdio.h>
#include <stdlib.h>

typedef struct { int id; char name[16]; float score; } Stu;

void write_txt(const char *path){
    FILE *fp = fopen(path, "w");
    if(!fp) { perror(path); exit(1); }
    Stu s[3] = {{1,"Tom",90}, {2,"Amy",95}, {3,"Bob",88}};
    for(int i=0;i<3;++i)
        fprintf(fp, "%d %s %.1f\n", s[i].id, s[i].name, s[i].score);
    fclose(fp);
}

void read_txt(const char *path){
    FILE *fp = fopen(path, "r");
    if(!fp) { perror(path); exit(1); }
    Stu tmp;
    while(fscanf(fp,"%d%s%f", &tmp.id, tmp.name, &tmp.score)==3)
        printf("read: %d %s %.1f\n", tmp.id, tmp.name, tmp.score);
    fclose(fp);
}

int main(){
    const char *f = "stu.txt";
    write_txt(f);
    read_txt(f);
    return 0;
}

int arr[3] = {1, 2, 3};
printf("%d\n", arr[5]); // 越界访问，结果未定义

int *ptr = NULL;
printf("%d\n", *ptr); // 解引用空指针，结果未定义

int x;
printf("%d\n", x); // x 未初始化，结果未定义

float x = 1.0;
float y = x / 0.0; // 浮点数除以零，结果未定义

int x = 10;
int y = x / 0; // 整数除以零，结果未定义

signed char x = 127;
x = x + 1; // signed char 溢出，结果未定义

int x = 1;
int y = x << 32; // 位移操作数太大，结果未定义

int *ptr = (int *)malloc(sizeof(int));
float *fptr = (float *)ptr; // 错误的类型转换，结果未定义

int *ptr = (int *)malloc(sizeof(int));
free(ptr);
*ptr = 10; // 内存越界，结果未定义

float x = sqrt(-1);
float y = sqrt(-1);
if (x == y) {
    printf("NaN values are equal\n");
}

int main(int argc, char *argv[]);

int main(int argc, char **argv);