C 代码片段:)- 技术经验 -卓越飞翔博客

数据类型

#include <stdio.h>

// struct datatype
struct person {
    char name[50];
    int age;
    float salary;
};

// enum datatype
enum color {red, green, blue};

int main() {

    // basic data types
    int a = 10; // 4 bytes
    float b = 5.5; //4 bytes
    char c = 'a'; //1 byte
    double d = 2.3; //8 bytes
    long double e; // 16 bytes (64-bit), 12 bytes (32-bit)
    short integer f; // 2 bytes
    long int g; //8 bytes (64-bit), 4 bytes (32-bit)


    // array
    int arr[5] = {1, 2, 3, 4, 5};

    // pointer
    int *ptr = &amp;a;

    // structure
    struct person person1;
    person1.age = 30;
    person1.salary = 55000.50;

    // enumeration
    enum color mycolor = red;

    // print values
    printf("integer: %dn", a);
    printf("float: %.2fn", b);
    printf("character: %cn", c);
    printf("array: %dn", arr[0]);
    printf("pointer: %dn", *ptr);
    printf("structure: name = %s", person1.name);
    printf("enumeration: %dn", mycolor);
    return 0;
}
</stdio.h>

真实数据类型：
浮动、双倍和长双倍

记忆片段

文本段（代码段）
它包含编译后的机器代码
数据段
存储由程序员初始化的全局变量和静态变量。
两种类型：

初始化数据段：包含在程序中显式初始化的全局变量和静态变量。
前任。 int x=2;

未初始化数据段（bss）：包含未显式初始化的全局变量和静态变量。
前任。 int x;

堆
它用于运行时动态内存分配。
堆叠
它存储局部变量、函数参数和返回地址。

c 代码片段:)

函数原型

是函数的声明，指定函数的名称、返回类型和参数，但不提供函数体。

（注意： 放在源文件的开头，可以有多个，但只能定义一个）

#include <stdio.h>

// function prototype with formal parameters
void func(char name[]);

int main() {
    char name[] = "alice";
    //actual parameters
    greet(name);
    return 0;
}

// function definition
void func(char name[]) {
    printf("hello, %s!n", name);
}
</stdio.h>

mod/模数

此运算符仅用于整数数据类型。在 float 数据类型上使用模数是非法的

#include <stdio.h>
#include <math.h>

int main() {
    double dividend = 7.5;
    double divisor = 2.0;
    double result;
    int i=2;
    i=i%10;//works on integer types

    result = fmod(dividend, divisor);
    printf("%.1f",result); //for float types

    return 0;
}

</math.h></stdio.h>

for循环

#include<stdio.h>
int main()
{
    int x;
    for(x=1; x



<h2>
  
  
  while 循环
</h2>



<pre class="brush:php;toolbar:false">#include<stdio.h>
int main()
{
    int j=1;
    while(j 



<h2>
  
  
  宏观
</h2>

<p>它是一段被赋予名称的代码片段，可用于在实际编译之前的预处理阶段在代码中执行文本替换。<br></p>

<pre class="brush:php;toolbar:false">#define pi 3.14159
#define square(x) ((x) * (x))

开关盒

#include <stdio.h>
int main() {
    int day = 3;

    switch (day) {
        case 1:
            printf("mondayn");
            break;
        case 2:
            printf("tuesdayn");
            break;
        default:
            printf("invalid dayn");
            break;
    }

    return 0;
}
</stdio.h>

内存管理

malloc：分配内存但不初始化它。内存中包含垃圾值。

calloc：分配内存并将所有位初始化为零。

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

int main() {
    int *array;
    int size = 5;

    // allocate memory for an array of integers
    array = (int *)malloc(size * sizeof(int));

    // deallocate the memory
    free(array);

    int *a[3];
    a = (int*) malloc(sizeof(int)*3);
    free(a);

    return 0;
}
</stdlib.h></stdio.h>

指针

它提供了一种直接访问和操作内存的方法。
指针是一个变量，它存储另一个变量的内存地址。指针不是直接保存数据值，而是保存数据在内存中的位置。

基本指针操作

声明：

int *ptr; // declares a pointer to an integer

初始化：

int x = 10;
int *ptr = &amp;x; // `ptr` now holds the address of `x`

取消引用：
访问存储在指定地址的值

int value = *ptr; // retrieves the value of `x` via `ptr`

样品

#include <stdio.h>

int main() {
    int a = 5;         // normal integer variable
    int *p = &amp;a;       // pointer `p` points to `a`

    printf("value of a: %dn", a);          // output: 5
    printf("address of a: %pn", (void*)&amp;a); // output: address of `a`
    printf("value of p: %pn", (void*)p);   // output: address of `a`
    printf("value pointed to by p: %dn", *p); // output: 5

    *p = 10; // modifies `a` through the pointer

    printf("new value of a: %dn", a);      // output: 10

    return 0;
}
</stdio.h>

指向指针的指针

int x = 10;
int *ptr = &amp;x;
int **pptr = &amp;ptr; // pointer to pointer

指向结构体的指针

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

// define a structure
struct person {
    char name[50];
    int age;
};

int main() {
    // declare a pointer to a structure
    struct person *ptr;

    // allocate memory for the structure
    ptr = (struct person *)malloc(sizeof(struct person));
    if (ptr == null) {
        printf("memory allocation failedn");
        return 1;
    }

    // use the arrow operator to access and set structure members
    strcpy(ptr-&gt;name, "alice");
    ptr-&gt;age = 30;

    // print structure members
    printf("name: %sn", ptr-&gt;name);
    printf("age: %dn", ptr-&gt;age);

    // free allocated memory
    free(ptr);

    return 0;
}
</string.h></stdlib.h></stdio.h>

关键词

外部的

用于声明在另一个文件中或稍后在同一文件中定义的全局变量或函数。

#include <stdio.h>

int main() {
    extern int a;  // accesses a variable from outside
    printf("%dn", a);
    return 0;
}
int a = 20;
</stdio.h>

静止的

全局静态变量：
全局静态变量是在任何函数外部使用 static 关键字声明的。
范围仅限于声明它的文件。这意味着它无法从其他文件访问。如果没有显式初始化，全局静态变量会自动初始化为零。

#include <stdio.h>

static int global_var = 10; // global static variable

void display(void) {
    printf("global variable: %dn", global_var); // accesses global static variable
}

int main(void) {
    display(); // prints 10
    global_var = 20;
    display(); // prints 20
    return 0;
}
</stdio.h>

局部静态变量
局部静态变量在函数内部使用 static 关键字声明。
范围仅限于声明它的函数。不能从函数外部访问它。如果没有显式初始化，局部静态变量会自动初始化为零。

#include <stdio.h>

void counter(void) {
    static int count = 0; // local static variable
    count++;
    printf("count: %dn", count); // prints the current value of count
}

int main(void) {
    counter(); // prints 1
    counter(); // prints 2
    counter(); // prints 3
    return 0;
}
</stdio.h>

注意： 在 c 中，当你有一个同名的全局变量和局部变量时，局部变量会在其作用域内隐藏（或隐藏）全局变量。

结构体

struct book
{
    char name[10];
    float price;
    int pages;
};

类型定义

它用于为现有类型创建别名

typedef unsigned int uint;

int main() {
    uint x = 10;  // equivalent to unsigned int x = 10;
    printf("x = %un", x);
    return 0;
}

typedef struct Ntype {
    int i;
    char c;
    long x;
} NewType;

连锁

指符号（变量和函数）跨源文件的可见性

外部链接：该符号在多个翻译单元中可见（全局）

内部链接：符号仅在定义它的翻译单元内可见

无（无链接）：符号在定义它的块之外不可见（局部变量）