C语言——每日一题（2）

最新推荐文章于 2024-10-30 15:52:39 发布
最新推荐文章于 2024-10-30 15:52:39 发布
阅读量82 收藏
点赞数
分类专栏： C++基础学习 文章标签： c语言 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_51451952/article/details/132741646
版权

题目要求

解析/etc/passwd文件内容，并保存到数组中，按照用户名和uid分别进行排序。

struct user {
    char *name;
    unsigned int uid;
    unsigned int gid;
    char home[64];
    char shell[64];
};

与前一天的每日一题，非常相似，解析过程基本相同。
C语言——每日一题（1）

咱们来看代码过程，经过了多次版本的优化，感觉还是进步了那么一点点。

1. 数组操作初始版本

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

#define BUF_SIZE 256

static int compareByUID(const void *, const void *);
static int compareByName(const void *, const void *);

struct user {
    char name[100];
    unsigned int uid;
}user;

int compareByName(const void *a, const void *b) {
    return strcmp(((struct user *)a)->name, ((struct user *)b)->name);
}

int compareByUID(const void *a, const void *b) {
    return ((struct user *)a)->uid - ((struct user *)b)->uid;
}

int parse_user(char* str, struct user *new_user){
    int flags = sscanf(str, "%[^:]:%*[^:]:%u", new_user->name, &new_user->uid);
    if(flags == 2){
        return 0;
    }
    return -1;
}

int main(int argc, char* argv[]){
    FILE *fp = fopen("passwd.txt", "r");
    if(fp == NULL){
        perror("open");
        exit(EXIT_FAILURE);
    }

    struct user userInfo[100];
    int userCount = 0;

    char buf[BUF_SIZE];

    while(fgets(buf, BUF_SIZE, fp)){
        if(parse_user(buf, &userInfo[userCount++])){
            printf("Parse users error\n");
            exit(EXIT_FAILURE);
        }
    }

    fclose(fp);

    printf("old userInfo>>>>>>>>>\n");
    for(int i = 0;i < userCount; i++){
        printf("Name: %s, Uid: %d\n", userInfo[i].name, userInfo[i].uid);
    }

    printf("========================================\n");
    printf("qsortByUID userInfo>>>>>>>>>\n");

    qsort(userInfo, userCount, sizeof(struct user), compareByUID);
    
    for(int i = 0;i < userCount; i++){
        printf("Name: %s, Uid: %d\n", userInfo[i].name, userInfo[i].uid);
    }

    printf("========================================\n");
    printf("qsortByName userInfo>>>>>>>>>\n");

    qsort(userInfo, userCount, sizeof(struct user), compareByName);
    
    for(int i = 0;i < userCount; i++){
        printf("Name: %s, Uid: %d\n", userInfo[i].name, userInfo[i].uid);
    }

    exit(EXIT_SUCCESS);
}

2. 指针操作版本

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

#define BUF_SIZE 1024

static int compareByUID(const void *, const void *);
static int compareByName(const void *, const void *);
struct user *parse_user(char* str);
void qSort_type(struct user **userInfo, int userCount, int compareUID, int compareName);
void free_user(struct user **userInfo, int userCount);

struct user {
    char name[100];
    unsigned int uid;
}user;

int compareByName(const void *a, const void *b) {
    return strcmp((*(struct user **)a)->name, (*(struct user **)b)->name);
}

int compareByUID(const void *a, const void *b) {
    return (*(struct user **)a)->uid - (*(struct user **)b)->uid;
}

struct user *parse_user(char* str){
    struct user *new_user = (struct user*)malloc(sizeof(struct user));
    if(new_user == NULL){
       err(EXIT_FAILURE, "malloc");
    }
    memset(new_user, 0, sizeof(*new_user));

    int flags = sscanf(str, "%[^:]:%*[^:]:%u", new_user->name, &new_user->uid);
    if(flags != 2){
        printf("error %d parsed", flags);
        printf("Error str: %s\n",str);
    }
    return new_user;
}

int main(int argc, char* argv[]){
    FILE *fp = fopen("passwd.txt", "r");
    if(fp == NULL){
        perror("open");
        exit(EXIT_FAILURE);
    }

    struct user **userInfo = NULL;
    int userCount = 0;

    char buf[BUF_SIZE];

    while(fgets(buf, BUF_SIZE, fp)){
        struct user *new_user = parse_user(buf);
        userInfo = (struct user **)realloc(userInfo, (userCount + 1) * sizeof(struct user *));
        if(userInfo == NULL){
            err(EXIT_FAILURE, "realloc");
        }
        userInfo[userCount++] = new_user;
    }

    fclose(fp);

    printf("old userInfo>>>>>>>>>\n");
    qSort_type(userInfo,userCount,0, 0);

    printf("========================================\n");
    printf("qsortByName userInfo>>>>>>>>>\n");
    qSort_type(userInfo,userCount, 1, 0);  

    printf("========================================\n");
    printf("qsortByUID userInfo>>>>>>>>>\n");
    qSort_type(userInfo,userCount, 0, 1);  
 
    free_user(userInfo,userCount);

    exit(EXIT_SUCCESS);
}

void qSort_type(struct user **userInfo, int userCount, int compareUID, int compareName){
    for(int i = 0; i < userCount; i++){
        if(!compareUID && compareName){
            qsort(userInfo, userCount, sizeof(struct user *), compareByName);
        }else if(compareUID && !compareName){
            qsort(userInfo, userCount, sizeof(struct user *), compareByUID);
        }
        printf("Name: %s, Uid: %d\n", userInfo[i]->name, userInfo[i]->uid);
    }
}

void free_user(struct user **userInfo, int userCount){
    for(int i = 0;i < userCount; i++){
        free(userInfo[i]);
    }
    free(userInfo);
}

3. 数组优化版本1

  1. 采用参数传递方式实现不同顺序
  2. 默认不加参数，则输出原序内容
  3. -n 按照name排序
  4. -d 按照uid排序
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<err.h>
#include<string.h>

#define BUF_SIZE 512

int getopt(int argc, char * const argv[], const char *optstring);
extern char *optarg;
extern int optind, opterr, optopt;

static int parse_user(char* str, struct user* new_user);
int commpare(const void *a, const void *b);
void qsort_type(int userCount);
void user_core(void);

struct user {
    char *name;
    unsigned int uid;
    unsigned int gid;
    char home[64];
    char shell[64];
};

enum sort_type {
    SORT_NONE=0,
    SORT_NAME=1,
    SORT_UID
};

static struct user userInfo[100];
static enum sort_type sort_type;

static int parse_user(char* str, struct user* new_user){
    memset(new_user, 0, sizeof(*new_user));

    if (sscanf(str, "%m[^:]:%*[^:]:%u:%u:%*[^:]:%63[^:]:%63s",  \
        &(new_user->name), &(new_user->uid), &(new_user->gid),new_user->home, new_user->shell) == 5){
            return 0;
    }else if(sscanf(str, "%m[^:]:%*[^:]:%u:%u::%63[^:]:%63s",     \
        &(new_user->name), &(new_user->uid), &(new_user->gid),new_user->home, new_user->shell) == 5){
            return 0;
    }

    if(new_user && new_user->name) free(new_user->name);
    if(new_user) free(new_user);

    return -1;
}

int commpare(const void *a, const void *b){
    switch (sort_type)
    {
    case SORT_NAME:
        return strcmp(((struct user*)a)->name, ((struct user*)b)->name);
        break;
    case SORT_UID:
        return ((struct user*)a)->uid - ((struct user*)b)->uid;
        break;
    default:
        break;
    }
}

void qsort_type(int userCount){
    if(sort_type != SORT_NONE){
        qsort(userInfo, userCount, sizeof(struct user), commpare);
    }
    return;
}

void user_core(void){
    FILE* fp = fopen("passwd.txt", "r");
    if(fp == NULL){
        perror("fopen");
        exit(EXIT_FAILURE);
    }
    char buf[BUF_SIZE];
    int userCount = 0;

    while(fgets(buf, sizeof(buf), fp)){
        if(parse_user(buf, &userInfo[userCount++])){
            printf("parse_user error\n");
            exit(EXIT_FAILURE);
        }
    }
    fclose(fp);
    qsort_type(userCount);

    printf("name\t uid\t gid\t home\t shell\n");
    for(int i = 0;i < userCount; i++){  
        printf("%s\t %u\t %u\t %s\t %s\n",  \
        userInfo[i].name, userInfo[i].uid, userInfo[i].gid,userInfo[i].home, userInfo[i].shell);
    }

    for(int i = 0;i < userCount; i++){
        if(userInfo[i].name) free(userInfo[i].name);
    }
}

int main(int argc, char *argv[]){
    sort_type = SORT_NONE;
    int opt;
    while((opt = getopt(argc, argv, "nd")) != -1){
        switch (opt)
        {
        case 'n':
            sort_type = SORT_NAME;
            break;
        case 'd':
            sort_type = SORT_UID;
            break;
        default:
            (void)fprintf(stderr, "Usage: %s [-nd] \n",argv[0]);
            exit(EXIT_FAILURE);
        }
    }
    // printf("optind = %d\n", optind);
    if(optind > argc){
        fprintf(stderr, "Expected argument after options\n");
        exit(EXIT_FAILURE);
    }
    user_core();

    return 0;
}

4. 数组继续优化2

方法3采用数组固定分配内存，利用率低。

  1. 优化采用动态内存分配的方式完成
  2. 加入DEBUG以跟踪代码，方便调试
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<err.h>
#include<string.h>

#define BUF_SIZE 255

#define DEBUG
#ifdef DEBUG
#define DPRINTF(format,...)                                                 \
    do { printf("%s::%s "format,__FILE__,__FUNCTION__,##__VA_ARGS__);}while(0)
#else
#define DPRINTF(format,...)
#endif

struct user {
    char *name;
    unsigned int uid;
    unsigned int gid;
    char home[64];
    char shell[64];
};

enum sort_type {
    SORT_NAME,
    SORT_UID,
    SORT_NONE
};

struct user *user_core(struct user* users, int *num);
struct user *expand_malloc(struct user* users);
void print_users(struct user users[], int count);
void free_users(struct user users[], int count);
int compare(const void *a, const void *b);

static int _size = 2;
static enum sort_type sort_type;


struct user *user_core(struct user *users, int *num){

    struct user *u = users;
    char buf[BUF_SIZE];

    FILE *fp = fopen("/etc/passwd","r");
    if(fp == NULL) goto error;

    while(fgets(buf, sizeof(buf), fp) != NULL){
        memset(u, 0, sizeof(*u));
        int n;
        n = sscanf(buf, "%m[^:]:%*[^:]:%u:%u:%*[^:]:%63[^:]:%63s",&(u->name),&(u->uid),&(u->gid),u->home,u->shell) == 5 
        | sscanf(buf, "%m[^:]:%*[^:]:%u:%u::%63[^:]:%63s",&(u->name),&(u->uid),&(u->gid),u->home,u->shell) == 5 ;

        if(n != 0){
            if((++u - users) >= _size){
                users = expand_malloc(users);
                u = users + (_size / 2);
            }
            continue;
        }else{
            *num = u - users;
            DPRINTF("Parse Error: %d\n",n);
            goto error;
        }
    }
    *num = u - users;
    DPRINTF("%d users be parsed\n", *num);
    fclose(fp);
    
    return users;
    
error:
    if(u && u->name) free(u->name);
    if(u)            free(u);
    if(fp)           fclose(fp);
    exit(EXIT_FAILURE);
}

struct user *expand_malloc(struct user* users){
    struct user *new = users;
    _size = _size * 2;
    new = (struct user *)realloc(users, sizeof(struct user) * _size);
    if(new == NULL) exit(EXIT_FAILURE);
    return new;
}

void print_users(struct user users[], int count){
    struct user *u = users;
    DPRINTF("Name\tuid\tgid\thome\tshell\n");
    for(int i = 0; i < count; i++, u++){
        DPRINTF("%s\t%u\t%u\t%s\t%s\n",u->name,u->uid,u->gid,u->home,u->shell);
    }
}

void free_users(struct user users[], int count){
    for(int i = 0; i < count; i++){
        free(users[i].name);
    }
    free(users);
}

int compare(const void *a, const void *b){
    switch(sort_type)
    {
        case SORT_NAME:
            return strcmp(((struct user *)a)->name, ((struct user *)b)->name);
            break;
        case SORT_UID:
            return ((struct user *)a)->uid - ((struct user *)b)->uid;
            break;
        default:
            DPRINTF("sort_type Invalid.\n");
            exit(EXIT_FAILURE);
    }
    return -1;
}

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

    struct user *users = malloc(sizeof(struct user) *_size);
    sort_type = SORT_NONE;
    int opt;
    int count = 0;

    users = user_core(users, &count);

    while((opt = getopt(argc, argv, "nd")) != -1){
        switch(opt){
            case 'n':
                sort_type = SORT_NAME;
                break;
            case 'd':
                sort_type = SORT_UID;
                break;
            default:
                (void)fprintf(stderr, "Usage: %s -[nd]\n",argv[0]);
                exit(EXIT_FAILURE);
        }
    }

    if(optind > argc){
        fprintf(stderr, "Expected argument after options\n");
        exit(EXIT_FAILURE);
    }
    
    
    DPRINTF("\033[0;33m+====================================================+\033[5m\n");
    print_users(users, count);

    qsort(users, count, sizeof(struct user), compare);

    DPRINTF("\033[0;32m+=====================Qsort=========================+\033[5m\n");
    print_users(users, count);

    free_users(users, count);

    return 0;
}

输出结果：
不加参数
-n 以name排序
-d 以uid排序

每天进步一点点，上传一张苏州落日下的大裤衩照片，很不错哦
在这里插入图片描述
关注知乎：
C语言 每日一题（2）

骑行的小牛
关注
专栏目录
力扣——每日一题 ——C语言求一年中的第几天
爱编程的晖哥的博客
01-04 943
题目来源于力扣——1154. 一年中的第几天 - 力扣（LeetCode） (leetcode-cn.com) 题目描述如下： 给你一个字符串 date ，按 YYYY-MM-DD 格式表示一个 现行公元纪年法 日期。请你计算并返回该日期是当年的第几天。 通常情况下，我们认为 1 月 1 日是每年的第 1 天，1 月 2 日是每年的第 2 天，依此类推。每个月的天数与现行公元纪年法（格里高利历）一致。 示例 1： 输入：date = "2019-01-09" 输出：9 示例 2： 输入
C语言——每日一题（1）
m0_51451952的博客
09-07 98
每天练习一道C语言，进步一点点
C语言——每日一题
weixin_73906153的博客
05-26 886
举个例子：先从5开始，用5/7，无法整除，让5*2=10，用10/7，无法整除，让5*3=15，用15/7，无法整除……大概思路就是让其中一个数a乘以一个从一开始逐步递增的数i，得到的结果假若能整除b，那么此时的a*i就是要求的最小公倍数。这两个数假设为a和b，他们相乘得到的数ret一定能将这两个数整除，但是ret是不是最小公倍数还不一定，所以可以将a和b相乘的结果c进行减减操作，假若也能得到能整除a和b的数，将c赋值给ret，如此往复，直到c不小于a和b中的最大值。向后移动，直到遇到了空格就停止，。
C语言——每日一题（轮转数组）
yiqingaa的博客
05-07 510
前不久学习了时间复杂度的概念，便在力扣上刷了一道需要参考时间复杂度的题——轮转数组这道题不能使用暴力算法，因为这道题对时间复杂度的要求不能为O（N^2）。因此我们只能使用其他，简便的方法过关。
c语言基础——每日一题（2）
m0_74091652的博客
10-25 369
题目：编写函数 Htoi(s)，把由十六进制数字组成的字符串（包含可选的前缀 0x或0X）转换为与之等价的整型值。字符串中允许包含的数字与字符包括：0-9、a-f以及A-F。
c语言基础——每日一题（1）
m0_74091652的博客
10-24 467
题目：编写一个程序以确定的分别由signed及unsigned限定的char，short，int与long类型变量的取值范围。采用打印标准头文件的相应值以及直接计算两种方式实现。
C语言每日一题——单词接龙
2301_80163571的博客
06-09 625
一人先写一个英文单词，然后另一个人回复一个英文单词，要求回复单词的开头有若干个字母和上一个人所写单词的结尾若干个字母相同，重合部分的长度不限。（如阿泰输入happy，小菲可以回复python，重合部分为py。）现在，小菲刚刚回复了阿泰一个单词，阿泰想知道这个单词与自己发过去的单词的重合部分是什么。他们两人都是喜欢写长单词的英语大神，阿泰觉得用肉眼找重合部分实在是太难了，所以请你编写程序来帮他找出重合部分。（注：不考虑没接上的情况）输入格式: "%s%s"输出格式： "%s\n"
C语言每日一题——数字金字塔
2201_75324712的博客
01-06 4304
C语言每日一题
C语言每日一题——查找数字
2201_75324712的博客
01-12 1684
C语言查找数字
C语言每日一题——打印素数
FSRMWK的博客
12-29 527
若a为素数，则b/c只能为1，c/b只能为a;这样我们只需要保证，2~sqrt（a）没有可被a整除的除数就可以判断a是素数，这样就可以省去一半的循环。3.对于一个数，假定它是素数，创建一个变量flag，并初始化为1，若不符合要求将flag赋值为1；2.假定一个数字 i ，若想判断 i 不是素数，则需保证2~(i-1),的除数，不能被 i 整除，也就是没有余数。1.这里要用到两层嵌套循环（外层：循环这100个数字，内层：判断这100个数字是否是素数，符合数字要求打印出来）素数的能被1和它本身整除的数；
C语言(每日一题)——数据结构——创建一条带头结点的单链表(详细过程)
yingyang20010112的博客
07-25 1973
代码】C语言(每日一题)——数据结构——创建一条带头结点的单链表(详细过程)
C语言每日一题——打印1~100的奇数
2301_79076048的博客
09-05 1484
使用C语言写一个程序打印1~100之间的奇数，要求输出的数字用空格分隔。
C语言(每日一题)——数据结构——归并两条有序链表(详细过程)
yingyang20010112的博客
07-25 878
C语言(每日一题)——数据结构——归并两条有序链表(详细过程)
算法笔记——每日一题（完结）
qq28117036的博客
09-08 2329
算法笔记 From 2021-9-08 To My Death 以前当兵的时候，每次搞30公里强行军都很累。于是我会在50斤的背囊上写着：行百里者半九十——>靠着这句话，即使腿抽筋着，我都能坚持自己完成下来。 现在，我同样用这句话来激励自己，天下没有难学的技术，只有半途而废的人。不要求我一定能成为技术大牛（毕竟这需要一定的天赋和机遇） 旦求无愧于自己。平凡而不平庸即可。 《比昨天的自己更好一点，比明天的自己更差一点》
C. Add Zeros（cf982）
m0_74310050的博客
10-30 680
题意：给定长度为n的数组a，可以进行以下操作：选择一个位置i，并且ai=a的长度+1-i；在a的末尾添加i-1个零，多次执行操作后数组a的最大可能长度是多少。分析：ai=|a|-i+1，所以|a|=ai+i-1，用map记录每个点都需要多少长度才可以变,记得vis开大点不然放不下。
2024年，Rust开发语言，现在怎么样了?
LiangGang365的专栏
10-27 1174
Rust到底好不好用，最终还是要看具体的业务场景应用。比如，目前用Rust来编写纯UI的前端，可能还不是很成熟。但在内存管理、安全性和性能优化等领域，Rust无疑是一种非常优秀的语言选择。国内华为、字节、百度、阿里、美团等在通用组件、基础平台系统都在使用rust，其他国内数据库厂商、交易所、理想汽车、小鹏汽车等，以及大量在区块链、游戏行业提供的远程职位
智慧建造总体策划方案（76页）.pptx
11-02
智慧建造总体策划方案（76页）
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件
最新发布
11-02
基于 Python2.7 和 PyQT4 开发的 modbus 通信采集软件，已在 windows、deepin linux 和树莓派上测试！
LLC simulink仿真《slx模型文件》
11-02
LLC simulink仿真《slx模型文件》 LLC谐振转换器是一种高效的直流-直流(DC-DC)电源转换器，因其独特的谐振特性而得名。在电力电子领域，LLC仿真对于理解和优化这种转换器的性能至关重要。Simulink是MATLAB环境下的一个强大工具，用于建立和仿真复杂系统，包括电力电子系统。 标题“LLC simulink仿真”指的是使用Simulink进行LLC谐振转换器的建模和仿真。通过Simulink，工程师可以模拟LLC转换器在不同工作条件下的行为，如负载变化、输入电压变动以及控制策略的影响。 **LLC电路的基本原理：** LLC谐振转换器结合了升压（Boost）、降压（Buck）和串联谐振（Series Resonant）三种拓扑结构的特点。它由主开关、副开关、电感、电容和二极管组成。谐振电容和电感形成谐振回路，使得开关器件能在零电压或零电流条件下切换，从而降低开关损耗并提高效率。 **仿真过程：** 在Simulink中，首先需要建立LLC转换器的模型，包括各个元件的参数设定。这包括主开关和副开关的开关频率、谐振电容和电感的值、二极管的反向恢复特性等。然后，设
C语言进阶学习——课后习题与阶段考核解析
资源摘要信息:"《带你学C带你飞》是一套以C语言学习为主题的教程，涵盖了从入门级的基础知识到进阶技能，最终达到探索C语言的高级特性的教学内容。该教程被划分为三个阶段，每个阶段都配备了相应的课后习题和答案，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值