【C语言】C语言学习笔记

已于 2023-01-07 17:49:58 修改
阅读量144 收藏
点赞数
文章标签： c语言 学习 开发语言
于 2023-01-07 17:48:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/karl_clemens/article/details/128593308
版权

2023-1-7 markclemens

文章目录

hello

#include <stdio.h>
 
int main()
{
    /* 我的第一个 C 程序 */
    printf("Hello, World! C\n");
 
    return 0;
}

#include <stdio.h>

int main() {
    printf("FILE LINE: %s / %d\n", __FILE__, __LINE__);

    printf("DATE TIME: %s / %s\n", __DATE__, __TIME__);

    printf("ANSI: %d\n", __STDC__);
    return 0;
}

demo

enum_struct.c

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

enum DAY {
    MON, TUE=2, WED
} day1 = WED;

struct BOOK {
    char title[50];
    char author[50];
    int book_id;
} book1 = {"CBook", "Clemens", 5};

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

int main() {
    enum DAY day2;

    day2 = TUE;
    day1 = MON;

    printf("enum day1: %d\n", day1);
    printf("enum day2: %d\n", day2);

    printf("struct book1: title:%s, autthor:%s, id:%d.\n", 
        book1.title, book1.author, book1.book_id);
        
    strcpy(data.str, "union..");
    printf("union data.str: %s", data.str);
    return 0;
}

file.c

file_test.txt

test fputs...
test fprintf...


#include <stdio.h>

int main() {
    FILE *fp = NULL;
    char buff[255];
    const char FIEL_PATH[] = "file_test.txt";

    // overwrite (create if not exists)
    fp = fopen(FIEL_PATH, "w+");
    fputs("test fputs...\n", fp);
    fprintf(fp, "test fprintf...\n");
    fclose(fp);

    // read  // fgets contains line end mark
    fp = fopen(FIEL_PATH, "r");
    fgets(buff, 255, (FILE*)fp);
    printf("LINENO 1: %s*\n", buff);
    fclose(fp);
    return 0;
}

gcd_lcm_algo.c

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

/*
gcd 最大公约数（因子） divisor
lcm 最小公倍数（倍数） multiple
*/

int main()
{
    int n1, n2, gcd, lcm;
    printf("input two integer:\n");
    scanf("%d %d", &n1, &n2);

    int i = n1 < n2 ? n1 : n2;
    for (; i > 0; i--)
    {
        if (n1 % i == 0 && n2 % i == 0)
        {
            gcd = i;
            break;
        }
    }
    lcm = n1 * n2 / gcd;
    printf("gcd:%d, lcm: %d", gcd, lcm);
    return 0;
}

malloc_free.c

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

void op_judge(void *p)
{
    if (p != NULL)
        return;
    fprintf(stderr, "Error - allocate memory failed\n");
    exit(1);
}
int main()
{
    char name[100];
    char *desc;
    strcpy(name, "~name[100]~");

    // calloc
    // desc = (char *)calloc(50, sizeof(char));

    // malloc
    desc = (char *)malloc(50 * sizeof(char));
    op_judge(desc);
    strcpy(desc, "desc = (char *)malloc(100 * sizeof(char));");
    printf("1. malloc -- %s\n", desc);

    // realloc
    void *p = realloc(desc, 100 * sizeof(char));
    op_judge(p);
    desc = (char *)p;
    strcat(desc, "void *p = realloc(desc, 10 * sizeof(char));desc = (char *)p;");
    printf("2. realloc --  %s\n", desc);

    // free
    free(desc);
    printf("3. free -- free(desc);");
    return 0;
}

pointer2pointer.c

#include <stdio.h>

int main() {
    int v;
    int *p1;
    int **p2;

    v=100;
    p1=&v;
    p2=&p1;

    printf("v = %d\n", v);
    printf("&v = %p\n", &v);
    printf("p1 = %p\n", p1);
    printf("&p1 = %p\n", &p1);
    printf("p2 = %p\n", p2);
    printf("&p2 = %p\n", &p2);
    printf("*p1 = %d\n", *p1);
    printf("**p2 = %d\n", **p2);
    printf("*p2 = %p\n", *p2);

    return 0;
}

pointer4func.c

#include "stdio.h"
#include "stdlib.h"
#include "time.h"

// func declaration  
// 指针函数，即返回值是指针的函数；而函数指针是指向函数的指针。
int *getAvg(int *arr, int size, double *avg);

int main()
{
    // random seed
    srand(time(NULL));

    // def vars
    const int SIZE = 5;
    int arr[5] = {4564, 4654, 7, 46, 578};
    double avg=0;
    int *res;

    // 指针函数 getAvg()
    res = getAvg(arr, SIZE, &avg);
    printf("1. pointer FUNC: avg of arr: %lf; res: %d\n", avg, *res);

    // 函数指针 pfun=getAvg  *返回值是指针 (*函数指针) *形参中的指针
    int *(*pfun)(int *, int, double *);
    pfun = getAvg;
    res = pfun(arr, SIZE, &avg);
    printf("2. func Pointer: avg of arr: %lf; res: %d", avg, *res);
    return 0;
}

// func definition
int *getAvg(int *arr, int size, double *avg)
{
    int sum = 0;
    for (int i = 0; i < size; i++)
    {
        sum += arr[i];
    }
    *avg = (double)sum / size;

    int r = rand();
    int *res = &r;
    return res;
}

precompile.c

#include <stdio.h>

int main() {
    printf("FILE LINE: %s / %d\n", __FILE__, __LINE__);

    printf("DATE TIME: %s / %s\n", __DATE__, __TIME__);

    printf("ANSI: %d\n", __STDC__);
    return 0;
}

recur_algo.c

#include <stdio.h>

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

int main()
{
    long res = factorial(5);
    printf("fac(5) = %ld", res);
    return 0;
}

gdb_tool

main.c

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

struct TEST
{
    int i;
    short sh;
    char *p; // char p[0];
};

int main()
{
    struct TEST *pt = NULL;
    return 0;
}
/*
gcc main.c -o main.exe -g  // prepare
gdb main.exe --silent  //start gdb
  list
  break 13
  run
  next
  print &pt
  print pt->i
  quit
*/

void test_struct(struct TEST *sp)
{
    printf("gdb test: %s", __TIME__);
    sp->i = 2; // (*sp).i = 5;
    sp->p = malloc(sizeof(char) * sp->i);
}

sort_algo

bubble_sort.c

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

#define DIM2 2
static int step_count = 0;

void bubble_sort(int arr[][DIM2], const int size);
void quick_sort_3ways(int arr[][DIM2], int start, int end);

void array_print(int arr[][DIM2], const int size)
{
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            printf("arr[%d][%d]: %d ", i, j, arr[i][j]);
        }
        printf("\n");
    }
}

int swap(int eleA[DIM2], int eleB[DIM2])
{
    int tmp[DIM2] = {eleA[0], eleA[1]};
    eleA[0] = eleB[0];
    eleA[1] = eleB[1];
    eleB[0] = tmp[0];
    eleB[1] = tmp[1];
}

int main()
{
    srand(time(NULL));
    int arr[][DIM2] = {
        {7, 1},
        {2, 1},
        {2, 1},
        {1, 4},
        {2, 6},
        {1, 1},
    };
    const int SIZE = sizeof(arr);
    const int LEN = sizeof(arr) / sizeof(arr[0]);
    printf("size:%d, len:%d\n", SIZE, LEN);
    array_print(arr, LEN);

    // bubble sort >>>>>>>>>>>>>>>>>>>>>>>>>>
    step_count = 0;
    bubble_sort(arr, LEN);
    printf("\nafter bobble sort: (step_count:%d)\n", step_count);
    array_print(arr, LEN);

    int arr2[][DIM2] = {
        {7, 1},
        {2, 1},
        {2, 1},
        {1, 4},
        {2, 6},
        {1, 1},
    };
    // quick sort 3way >>>>>>>>>>>>>>>>>>>>>>>>>>
    step_count = 0;
    quick_sort_3ways(arr2, 0, LEN);
    printf("\nafter quick sort: (step_count:%d)\n", step_count);
    array_print(arr2, LEN);

    return 0;
}

// sort: e1 asc, e2 desc
int compare(int eleA[DIM2], int eleB[DIM2])
{
    if (eleA[0] < eleB[0] || (eleA[0] == eleB[0] && eleA[1] > eleB[1]))
        return -1;
    else if (eleA[0] == eleB[0] && eleA[1] == eleB[1])
        return 0;
    else
        return 1;
}

void bubble_sort(int arr[][DIM2], const int size)
{
    for (int i = size - 1; i > 0; i--)
    {
        for (int j = 0; j < i; j++)
        {
            step_count++; // todo
            int sorter = compare(arr[j], arr[j + 1]);
            if (sorter == 1)
            {
                swap(arr[j], arr[j + 1]); // let bigger move to right
            }
        }
    }
}

void quick_sort_3ways(int arr[][DIM2], int start, int end)
{
    // terminate condition
    if (end - start <= 1)
        return;
    int PIVOT_POS = rand() % end; // choose a pivot randomly
    int pivot[DIM2] = {arr[PIVOT_POS][0], arr[PIVOT_POS][1]};

    // partition: lt pivot / eq pivot / gt pivot
    int cur = start, j = start, k = end - 1; // *j <= pivot < *k

    while (cur < k)
    {
        step_count++; // todo
        int sorter = compare(arr[cur], pivot);
        if (sorter == -1)
        {
            swap(arr[cur], arr[j++]); // 扩充less区  *j是第一个等于pivot的
            cur++;                    // swap后，当前变成了equal点 // 不加不影响功能，影响效率
        }
        else if (sorter == 1)
            swap(arr[cur], arr[k--]); // 扩充great区 *j是第一个大于pivot的
        else
            cur++; // 跳过equal点
    }
    // quick sort subarray
    quick_sort_3ways(arr, start, j);
    quick_sort_3ways(arr, k, end - k);
}

qsort_test.c

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

#define DIM2 2
void array_print(int arr[][DIM2], const int size)
{
    for (int i = 0; i < size; i++)
    {
        for (int j = 0; j < 2; j++)
        {
            printf("arr[%d][%d]: %d ", i, j, arr[i][j]);
        }
        printf("\n");
    }
}

// sort: e1 asc, e2 desc
// int compare(const int eleA[DIM2], const int eleB[DIM2])
int compare(const void *eleA1, const void *eleB1)
{
    int *eleA = (int *)eleA1;
    int *eleB = (int *)eleB1;
    if (eleA[0] < eleB[0] || (eleA[0] == eleB[0] && eleA[1] < eleB[1]))
        return -1;
    else if (eleA[0] == eleB[0] && eleA[1] == eleB[1])
        return 0;
    else
        return 1;
}

int main()
{
    int arr[][DIM2] = {
        {7, 1},
        {2, 1},
        {2, 1},
        {1, 4},
        {2, 6},
        {1, 1},
    };
    const int bytes = sizeof(arr);
    const int size = sizeof(arr) / sizeof(arr[0]); // arr[0] : 
    printf("bytes:%d, size:%d,\n", bytes, size);
    printf("\nafter qsort: \n");

    // qsort >>>>>>>>>>>>>>>>>>>>>>>>>>
    qsort(arr, size, sizeof(arr[0]), compare);
    array_print(arr, size);

    return 0;
}

rand.c

#include "stdio.h"
#include "stdlib.h"
#include "time.h"

// func declaration  
// 指针函数，即返回值是指针的函数；而函数指针是指向函数的指针。
int *getAvg(int *arr, int size, double *avg);

int main()
{
    // random seed
    srand(time(NULL));

    // def vars
    const int SIZE = 5;
    int arr[5] = {4564, 4654, 7, 46, 578};
    double avg=0;
    int *res;

    // 指针函数 getAvg()
    res = getAvg(arr, SIZE, &avg);
    printf("1. pointer FUNC: avg of arr: %lf; res: %d\n", avg, *res);

    // 函数指针 pfun=getAvg  *返回值是指针 (*函数指针) *形参中的指针
    int *(*pfun)(int *, int, double *);
    pfun = getAvg;
    res = pfun(arr, SIZE, &avg);
    printf("2. func Pointer: avg of arr: %lf; res: %d", avg, *res);
    return 0;
}

// func definition
int *getAvg(int *arr, int size, double *avg)
{
    int sum = 0;
    for (int i = 0; i < size; i++)
    {
        sum += arr[i];
    }
    *avg = (double)sum / size;

    int r = rand();
    int *res = &r;
    return res;
}

end

MarkClemens
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言n番战--字符串（六）
weixin_50546241的博客
05-26 431
嵌入式之路，贵在日常点滴 ---阿杰在线送代码
C语言学习笔记.docx
12-16
C语言学习笔记 本文档是一份C语言学习笔记，涵盖了C语言的基本概念、数据类型、运算符、控制结构、函数等内容。 1. 第一个C程序 C语言的第一个程序是Hello World程序。该程序使用#include "stdio.h"指令包含标准...
C语言学习笔记
weixin_42098295的博客
04-22 913
变量和数据类型：理解基本数据类型（int, char, float, double等）以及更复杂的类型，如数组和结构体。标准输入输出：熟悉printf和scanf函数的使用，以及其他的输入输出函数（如fgets和fputs）。函数定义和调用：理解如何定义和调用函数，参数传递的方式，以及返回值的使用。指针的基本概念：理解指针的定义和用途，以及如何使用指针访问内存地址。指针与函数：掌握如何通过指针传递函数的参数，以及返回指针类型的函数。联合：了解联合的定义和使用，以及与结构体的区别。
C语言学习笔记：函数
WHNWZY的博客
06-17 1537
函数别称方法、子例程或程序。每个C程序都至少有一个函数，即主函数 main()；使用一个函数需要进行函数声明、函数定义、调用函数。函数声明提供了函数的名称、返回类型和参数。函数声明:函数类型 函数名（形参）；函数定义提供了函数的实际主体。函数定义：函数首部、函数体函数首部：函数类型 函数名（形参）函数调用：通过调用函数来完成已定义的任务。函数调用：函数名（实参）;
c语言学习笔记
wc_12345654321的博客
09-13 79
C语言用printf()打印u8,u16,u32等参数类型 c - scanf 十六进制到 C 中的 uint8_t
C语言 学习笔记
m0_75212548的博客
07-23 121
分支与循环（2）
00_C语言学习笔记
W_mid的博客
02-20 772
利用VSCode学习C语言的准备工作
c语言学习笔记10.18
2302_80005066的博客
10-18 78
由于我并不是计算机相关专业的学生，平时没有很多应用c语言的机会。但是我以后希望能走金融工程方向，希望以此为起点，学会应用计算机解决金融问题。希望能通过4个月的学习和练习。能够初步系统掌握c语言的相关知识，并尝试用c语言编程解决生活中的一些问题。大家好，我是Akiko。从今天开始在csdn更新自己的c语言学习记录。希望能够坚持这几个月的学习。
学习笔记--C语言
ZKCMQ的博客
01-17 409
printf ：意为打印+格式。库函数，使用时必须带着头文件。printf("我学编程为了更好的结合电子信息工程");int，return ：关键字，不能随便用，不能改，不能造。printf("我是一年级的大学生\n");main ：主函数，程序的入口，有且只有一个。C语言中，字符要用单引号括起来。#include :包含。stdio.h ：头文件。
C语言学习笔记-函数
08-09 83
【代码】C语言学习笔记-函数。
C语言学习笔记：typedef
WHNWZY的博客
06-20 932
typedef 关键字，用来声明新的类型名来代替已有的类型名，可以使用它来为类型取一个新的名字一般形式：例如：BYTE b1, b2;等价于 int b1,b2；在这个类型定义之后，标识符BYTE可作为类型int的缩写gender a;等价于char a;
C语言学习笔记.doc
11-29
C语言学习笔记 本资源摘要信息对应的C语言学习笔记，涵盖了C语言的基本概念、语法规范、数据类型、常量定义、变量声明、函数调用、输入输出操作等方面的知识点。 一、C语言基本概念 * 一个C语言源程序可以由一个...
c语言学习笔记.pdf
11-16
c语言学习笔记.pdf
C语言学习笔记.zip
06-27
本压缩包“C语言学习笔记.zip”包含了丰富的C语言学习资料，主要集中在“c-notes-master”这个子目录下，适合初学者和有一定基础的程序员进行深入学习。 在C语言的学习中，首先要掌握的基本概念包括变量、数据类型...
c语言学习笔记 c语言学习笔记
08-06
这些是C语言学习的基础知识，理解并掌握它们对于编写有效的C语言程序至关重要。通过深入学习和实践，你可以进一步探索指针、数组、结构体、文件I/O等更高级的主题，从而成为C语言的熟练开发者。
【C语言】移位操作详解 - 《凌波微步 ! 》
EleganceJiaBao的博客
07-11 1191
移位操作符是C语言中非常重要的工具，提供了高效的位级操作方法。理解和正确使用移位操作符，对于编写高性能和高效能的程序至关重要。本文详细介绍了左移和右移操作符的使用方法、应用场景及注意事项，希望对您理解和使用C语言移位操作有所帮助。
【C/C++】内存相关
YZJincsdn的博客
07-11 878
起源：ptmalloc起源于Doug Lea的malloc实现，并由Wolfram Gloger进行改进，以支持多线程。目标：ptmalloc的主要目标是为多线程应用程序提供高效的内存分配和释放。名称含义：“pt”代表“pthreads”，指的是POSIX线程库，表明其支持多线程的特性。ptmalloc作为glibc中的默认内存分配器，在Linux系统中扮演着重要角色。它通过一系列机制来提高内存分配和释放的效率，并支持多线程应用程序。
【C语言】原码、反码、补码详解 -《码上有道 ! 》
最新发布
EleganceJiaBao的博客
07-15 651
补码的优点使得它成为现代计算机系统中普遍使用的整数表示方法。了解原码、反码和补码之间的关系和转换方法，对于理解计算机底层运算和处理负数具有重要意义。在C语言中，理解这些表示方法有助于更好地处理整数运算和位操作。
C调用C++接口
u010273224的博客
07-12 246
主要利用了C++的语言链接声明 extern “C” void funCPP，使得funCPP以C方式进行编译链接，让C语言的代码能够找到funCPP接口。
My-C-book.docx
06-17
C语言作为一门很好的入门语言，这是我的入门学习笔记。全程干货，带你快速上手、开始编程！包含详细的基本语法，例如：流程控制、排序算法、结构体、基本函数使用、查找算法、指针操作、内存管理、文件操作等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值