linux 统计文件夹下.c文件的名字和文件个数

好的，您可以使用以下命令来统计指定文件夹下所有 .c 文件的文件名和文件个数：

find /path/to/folder -name "*.c" -printf "%f\n" | sort | tee /path/to/output | wc -l

其中，`/path/to/folder` 是您想要统计的文件夹路径，`*.c` 表示匹配所有以 .c 结尾的文件，`%f\n` 表示输出文件名并换行，`sort` 表示按文件名排序，`tee /path/to/output` 表示将输出同时输出到屏幕和指定文件，`wc -l` 表示统计输出的行数，即文件个数。

这个命令会输出文件夹下所有 .c 文件的文件名列表，并统计文件个数。您可以将 `/path/to/output` 替换为您想要保存输出结果的文件路径。

相关问题

linux系统下用c语言实现统计/tmp文件夹及子文件夹下每个文件夹的大小和每个文件的大小，并找出占内存最大的文件夹和文件

你可以使用递归的方式遍历 `/tmp` 目录及其子目录下的所有文件和文件夹，并使用 `stat` 系统调用获取文件的大小，最终统计出每个文件夹的大小和每个文件的大小，再找出占内存最大的文件夹和文件。

以下是一个示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>
#include <string.h>

// 定义一个结构体用于存储文件夹的大小和路径
struct FolderSize {
    long long size;
    char path[1024];
};

// 递归遍历目录
void traverse_dir(const char *dir_path, long long *total_size, struct FolderSize *max_folder) {
    DIR *dir = opendir(dir_path);
    if (dir == NULL) {
        perror("opendir");
        return;
    }
    struct dirent *entry;
    struct stat st;
    long long folder_size = 0;
    while ((entry = readdir(dir)) != NULL) {
        // 构造文件路径
        char path[1024];
        snprintf(path, sizeof(path), "%s/%s", dir_path, entry->d_name);
        if (stat(path, &st) == -1) {
            perror("stat");
            continue;
        }
        if (S_ISDIR(st.st_mode)) {
            // 如果是目录，则递归遍历
            if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
                continue;
            }
            traverse_dir(path, &folder_size, max_folder);
        } else if (S_ISREG(st.st_mode)) {
            // 如果是普通文件，则累加文件大小
            folder_size += st.st_size;
            *total_size += st.st_size;
            // 如果文件大小比当前最大文件夹还大，则更新最大文件夹信息
            if (folder_size > max_folder->size) {
                max_folder->size = folder_size;
                strncpy(max_folder->path, dir_path, sizeof(max_folder->path));
            }
        }
    }
    closedir(dir);
    printf("Folder %s size: %lld bytes\n", dir_path, folder_size);
}

int main() {
    long long total_size = 0;
    struct FolderSize max_folder = {0, ""};
    traverse_dir("/tmp", &total_size, &max_folder);
    printf("Total size of /tmp and its subdirectories: %lld bytes\n", total_size);
    printf("Largest folder: %s (%lld bytes)\n", max_folder.path, max_folder.size);
    return 0;
}

注意，在程序中使用了 `strncpy` 函数来复制文件夹路径，以防止路径溢出问题。

linux系统下用c语言实现统计/tmp文件夹下每个文件夹得大小和每个文件得大小，并找出占内存最大的文件夹和文件，写出完整代码

以下是一个简单的C语言程序，可以实现统计/tmp文件夹下每个文件夹得大小和每个文件得大小，并找出占内存最大的文件夹和文件。其中，我们使用了Linux系统下的stat和dirent库函数来获取文件和目录的信息，使用了递归的方式来遍历文件夹。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <sys/stat.h>

#define MAX_PATH 1024

struct file_info {
    char name[MAX_PATH];
    off_t size;
};

struct dir_info {
    char name[MAX_PATH];
    off_t size;
};

void get_file_info(const char *path, struct file_info *info) {
    struct stat st;
    if (stat(path, &st) == 0) {
        strncpy(info->name, path, MAX_PATH);
        info->size = st.st_size;
    } else {
        perror("stat");
    }
}

void get_dir_info(const char *path, struct dir_info *info) {
    DIR* dir;
    struct dirent* ent;
    struct stat st;
    off_t size = 0;

    dir = opendir(path);
    if (dir == NULL) {
        perror("opendir");
        return;
    }

    while ((ent = readdir(dir)) != NULL) {
        char sub_path[MAX_PATH];
        if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0) {
            continue;
        }
        snprintf(sub_path, sizeof(sub_path), "%s/%s", path, ent->d_name);
        if (lstat(sub_path, &st) == 0) {
            if (S_ISDIR(st.st_mode)) {
                struct dir_info sub_info;
                get_dir_info(sub_path, &sub_info);
                size += sub_info.size;
            } else {
                size += st.st_size;
            }
        }
    }

    strncpy(info->name, path, MAX_PATH);
    info->size = size;

    closedir(dir);
}

int cmp_file_info(const void *a, const void *b) {
    const struct file_info *fa = (const struct file_info *)a;
    const struct file_info *fb = (const struct file_info *)b;
    if (fa->size < fb->size) {
        return 1;
    } else if (fa->size > fb->size) {
        return -1;
    } else {
        return 0;
    }
}

int cmp_dir_info(const void *a, const void *b) {
    const struct dir_info *da = (const struct dir_info *)a;
    const struct dir_info *db = (const struct dir_info *)b;
    if (da->size < db->size) {
        return 1;
    } else if (da->size > db->size) {
        return -1;
    } else {
        return 0;
    }
}

int main(int argc, char *argv[]) {
    struct file_info files[MAX_PATH];
    struct dir_info dirs[MAX_PATH];
    int num_files = 0, num_dirs = 0, i;
    off_t total_size = 0;

    DIR* dir;
    struct dirent* ent;
    struct stat st;

    dir = opendir("/tmp");
    if (dir == NULL) {
        perror("opendir");
        return 1;
    }

    while ((ent = readdir(dir)) != NULL) {
        char path[MAX_PATH];
        snprintf(path, sizeof(path), "/tmp/%s", ent->d_name);
        if (lstat(path, &st) == 0) {
            if (S_ISREG(st.st_mode)) {
                struct file_info info;
                get_file_info(path, &info);
                files[num_files++] = info;
                total_size += info.size;
            } else if (S_ISDIR(st.st_mode)) {
                struct dir_info info;
                get_dir_info(path, &info);
                dirs[num_dirs++] = info;
                total_size += info.size;
            }
        }
    }

    qsort(files, num_files, sizeof(struct file_info), cmp_file_info);
    qsort(dirs, num_dirs, sizeof(struct dir_info), cmp_dir_info);

    printf("Total size: %ld bytes\n", total_size);
    printf("Top 10 largest files:\n");
    for (i = 0; i < 10 && i < num_files; i++) {
        printf("%s: %ld bytes\n", files[i].name, files[i].size);
    }
    printf("Top 10 largest directories:\n");
    for (i = 0; i < 10 && i < num_dirs; i++) {
        printf("%s: %ld bytes\n", dirs[i].name, dirs[i].size);
    }

    closedir(dir);
    return 0;
}

这个程序会输出/tmp文件夹下的总大小，以及占内存最大的前10个文件和文件夹的大小。程序中使用了两个结构体，分别用于保存文件和目录的信息。在获取文件和目录的大小时，我们使用了递归的方式，遍历了目录下的所有文件和子目录。最后使用了qsort函数对文件和目录的信息进行了排序，以方便我们找出占内存最大的文件和文件夹。