C++17相关新特性¶

#include <filesystem>
namespace fs = std::filesystem; // 常用的命名空间别名

// 直接使用string进行构造
fs::path p1 = "C:/Users/Documents/file.txt";  // Windows路径
fs::path p2 = "/home/user/documents/file.txt"; // Unix路径

fs::path p = "/home/user/documents/file.txt";

p.filename();    // "file.txt"
p.extension();   // ".txt"
p.stem();        // "file"
p.parent_path(); // "/home/user/documents"
p.root_name();   // 返回根名称
p.is_absolute(); // 是否是绝对路径
p.is_relative(); // 是否是相对路径
p.string(); // 返回当前路径字符串"/home/user/documents/file.txt"

fs::path dir = "/home/user";
fs::path full = dir / "documents" / "file.txt"; // 使用/操作符连接路径

fs::file_status status = fs::status(path);
bool isDir = fs::is_directory(path);
bool isFile = fs::is_regular_file(path);
bool exists = fs::exists(path);
uintmax_t size = fs::file_size(path);
fs::file_time_type time = fs::last_write_time(path);

fs::create_directory(path);
fs::create_directories(path); // 创建多级目录

fs::copy(from, to, fs::copy_options::recursive);
fs::rename(from, to);
fs::remove(path);
fs::remove_all(path); // 递归删除

// 遍历单个目录
for (const auto& entry : fs::directory_iterator(path)) {
    // 显式将entry转换为path对象
    std::cout << entry.path() << std::endl;
}

// 递归遍历目录
for (const auto& entry : fs::recursive_directory_iterator(path)) {
    // 显式将entry转换为path对象
    std::cout << entry.path() << std::endl;
}

// 遍历单个目录
for (const auto& entry : fs::directory_iterator(path)) {
    if(fs:is_regular_file(entry))
    {
        // 判断是否是普通文件
    }
}

// 递归遍历目录
for (const auto& entry : fs::recursive_directory_iterator(path)) {
    if(fs:is_regular_file(entry))
    {
        // 判断是否是普通文件
    }
}

// entry是一个directory_entry对象
// 例如is_regular_file
entry.is_regular_file();
entry.is_directory();

fs::space_info info = fs::space("/home");
std::cout << "可用空间: " << info.available << " 字节\n";
std::cout << "总空间: " << info.capacity << " 字节\n";
std::cout << "空闲空间: " << info.free << " 字节\n";

fs::path current = fs::current_path(); // 获取当前工作目录
fs::current_path(newPath); // 修改当前工作目录

std::string path_str = current.string();

fs::path temp = fs::temp_directory_path(); // 获取临时目录

#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

int main() {
    try {
        // 创建目录
        fs::path dir = "example_directory";
        fs::create_directory(dir);

        // 创建文件
        std::ofstream(dir / "file1.txt") << "Hello, filesystem!";
        std::ofstream(dir / "file2.txt") << "Another file";

        // 创建子目录
        fs::create_directory(dir / "subdir");

        // 递归遍历并显示所有条目
        std::cout << "目录内容:\n";
        for (const auto& entry : fs::recursive_directory_iterator(dir)) {
            std::cout << entry.path() << " - ";
            if (fs::is_regular_file(entry.path())) {
                std::cout << fs::file_size(entry.path()) << " 字节";
            } else if (fs::is_directory(entry.path())) {
                std::cout << "目录";
            }
            std::cout << std::endl;
        }

        // 复制文件
        fs::copy(dir / "file1.txt", dir / "file1_copy.txt");

        // 删除整个目录
        fs::remove_all(dir);

        std::cout << "操作完成" << std::endl;
    } catch (const fs::filesystem_error& e) {
        std::cerr << "文件系统错误: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "标准异常: " << e.what() << std::endl;
    }

    return 0;
}

class string_view {
private:
    const char* _data;   // 指向字符序列的指针
    size_t _size;        // 序列的长度
};

#include <string_view>
#include <iostream>
#include <string>

int main() {
    // 从字符串字面量创建
    std::string_view sv1 = "Hello, string_view!";

    // 从std::string创建
    std::string str = "Hello, string!";
    std::string_view sv2 = str;

    // 从字符数组创建
    char arr[] = {'H', 'e', 'l', 'l', 'o'};
    std::string_view sv3(arr, 5);  // 必须指定长度

    std::cout << "sv1: " << sv1 << std::endl;
    std::cout << "sv2: " << sv2 << std::endl;
    std::cout << "sv3: " << sv3 << std::endl;

    return 0;
}

#include <string_view>
#include <iostream>

int main() {
    std::string_view sv = "Hello, string_view world!";

    // 基本属性
    std::cout << "长度: " << sv.size() << std::endl;  // 或 sv.length()
    std::cout << "是否为空: " << (sv.empty() ? "是" : "否") << std::endl;

    // 访问元素
    std::cout << "首字符: " << sv[0] << std::endl;
    std::cout << "末字符: " << sv.back() << std::endl;

    // 子串操作（不产生新内存分配）
    std::string_view sv_sub = sv.substr(7, 11);  // "string_view"
    std::cout << "子串: " << sv_sub << std::endl;

    // 查找操作
    size_t pos = sv.find("world");
    if (pos != std::string_view::npos) {
        std::cout << "'world'在位置: " << pos << std::endl;
    }

    // 移除前缀和后缀
    std::string_view sv2 = sv;
    sv2.remove_prefix(7);  // 移除"Hello, "
    std::cout << "移除前缀后: " << sv2 << std::endl;

    sv2.remove_suffix(7);  // 移除" world!"
    std::cout << "移除后缀后: " << sv2 << std::endl;

    return 0;
}

#include <string>
#include <string_view>
#include <iostream>
#include <chrono>

int main() {
    const int iterations = 1000000;
    std::string str = "这是一个测试字符串，用于演示string_view和string的性能差异";

    // 测试std::string
    auto start1 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        std::string substring = str.substr(5, 10);  // 创建新字符串，分配内存
    }
    auto end1 = std::chrono::high_resolution_clock::now();

    // 测试std::string_view
    auto start2 = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < iterations; ++i) {
        std::string_view substring = std::string_view(str).substr(5, 10);  // 无内存分配
    }
    auto end2 = std::chrono::high_resolution_clock::now();

    auto duration1 = std::chrono::duration_cast<std::chrono::milliseconds>(end1 - start1).count();
    auto duration2 = std::chrono::duration_cast<std::chrono::milliseconds>(end2 - start2).count();

    std::cout << "std::string 耗时: " << duration1 << " 毫秒" << std::endl;
    std::cout << "std::string_view 耗时: " << duration2 << " 毫秒" << std::endl;
    std::cout << "性能提升: " << (float)duration1 / duration2 << "倍" << std::endl;

    return 0;
}

std::string_view get_dangerous_view() {
    std::string local_str = "临时字符串";
    return local_str;  // 危险！返回了引用临时对象的视图
}  // local_str被销毁，string_view变为无效

void safer_usage() {
    std::string stored_str = "安全的字符串";
    std::string_view sv = stored_str;  // 安全，只要stored_str存在
    // 使用sv...
}

std::string_view sv = "Hello";
sv.remove_suffix(2);  // 现在sv指向"Hel"

// 错误用法
printf("%s", sv.data());  // 可能不以'\0'结尾！

// 正确用法
std::string temp(sv);  // 转换为std::string
printf("%s", temp.c_str());

// 好的用法 - 参数使用string_view
void process_data(std::string_view data) {
    // 处理数据...
}

// 避免的用法 - 返回string_view
std::string_view get_data() {
    static std::string data = "持久数据";  // 必须确保数据比view生命周期长
    return data;
}

std::string get_data(std::string_view data) {
    return data; // 错误，不允许隐式构造为string
}

std::string get_data(std::string_view data) {
    return std::string(data); // 正确
}