Início / coding / Perguntas / 79449553
Accepted
Giogre
Asked: 2025-02-19 04:39:08 +0800 CST

Usar `std::variant` para selecionar tipos após a entrada do prompt de comando é possível?

  • 772

Estou em um estágio muito inicial na escrita de um programa em C++ replicando as funções mais básicas do lscomando bash.

Eu uso o <filesystem>cabeçalho.

O std::filesystem::directory_iteratore std::filesystem::recursive_directory_iteratordessa biblioteca me ajudam a percorrer o caminho do arquivo de entrada de maneira superficial ou recursiva, respectivamente.

A entrada recebe um argv[1], que deve ser composto de um hífen inicial -, seguido por letras representando sinalizadores de opção. Flag Rrepresenta travessia recursiva de todos os subdiretórios, caso contrário, olhe apenas para o caminho fornecido.

argv[2]é o caminho do arquivo a ser explorado.

Minha dúvida, no entanto, é sobre como executar isso de forma padronizada ou se isso é possível.

Como teste, estou usando std::variantuma função option_R()que seleciona o correto directory_iteratordependendo se o -Rsinalizador está presente na entrada ou não.

Como isso seria polimorfismo de tempo de execução, estou cético quanto à possibilidade de implementar algo como o abaixo:

#include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include <variant>

#include <type_traits>
#include <concepts>

using namespace std;
using namespace std::filesystem;

template<typename T> concept isIter = 
  is_same<T, directory_iterator>::value || is_same<T, recursive_directory_iterator>::value;

template <isIter dirIterator>
dirIterator option_R(std::string_view options, const path &my_path) {
  variant<directory_iterator, recursive_directory_iterator> my_iter;
  if (options.find('R') != string::npos) {
    my_iter.emplace<recursive_directory_iterator>(my_path, directory_options::skip_permission_denied);
    return get<recursive_directory_iterator>(my_iter);
  } else {
    my_iter.emplace<directory_iterator>(my_path);
    return get<directory_iterator>(my_iter);
  }
}

template <isIter dirIterator>
void traverse(isIter &my_iter, vector<string> &my_vec) {
  cout << "This function traverses the given dir path, "
       << "stores all filenames found inside a vector." << endl;
  for (const auto &entry : my_iter)
    my_vec.push_back(entry.path().string());
}

int main(int argc, const char **argv) {
  const path sys_path{argv[2]};
  const string options{argv[1]};

  vector<string> files;
  if (options[0] == '-') {
    if (is_directory(sys_path)) {
      isIter file_iterator = option_R(options, sys_path);
      traverse(file_iterator, files);
    }
    cout << "after this the program will parse other options" << endl;
  } else {
    cout << "simply print all files" << endl;
  }
}

O acima não compila, entre outros motivos porque eu uso vagarosamente o conceito isIterpara invocar option_R()em main.

Haveria uma maneira de escrever option_R(), de modo que ele fizesse apenas uma coisa: selecionar o correto directory_iteratorde acordo com o sinalizador -Rfornecido ou não - e passá-lo de volta para main()?

Seria fácil agrupar option_R()e traverse()reunir em apenas uma função, mas isso faria várias coisas e o código seria mais difícil de entender.

c++

2 respostas

  1. Best Answer

    Você pode conseguir o que está tentando fazer com std::variante std::visit.

    A std::varianté uma união mais segura, que você pode usar para armazenar a std::filesystem::directory_iteratore a std::filesystem::recursive_directory_iterator, sem precisar alocar memória para ambos os iteradores separadamente.

    Com std::visitvocê você pode então std::variantpassar seu valor para uma função modelo (ou sobrecarregada) que pode funcionar com todos os tipos que ela std::variantpossui.

    Usando isso, podemos fazer com que sua option_R()função retorne um std::variantdos dois iteradores mencionados acima e, então, a traverse()função recebe um std::variantcomo argumento e o usa std::visitpara iterar sobre todos os arquivos da maneira esperada.

    #include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include <variant>

using IterVariant = std::variant<std::filesystem::directory_iterator, std::filesystem::recursive_directory_iterator>;

IterVariant option_R(std::string_view options, const std::filesystem::path& my_path) {
    if (options.find('R') != std::string_view::npos) {
        return std::filesystem::recursive_directory_iterator(my_path, std::filesystem::directory_options::skip_permission_denied);
    }
    return std::filesystem::directory_iterator(my_path);
}

void traverse(IterVariant& my_iter, std::vector<std::string>& my_vec) 
{
    std::cout << "This function traverses the given dir path, "
        << "stores all filenames found inside a vector.\n";

    std::visit([&my_vec](auto&& it) {
        for (const auto& entry : it) {
            my_vec.push_back(entry.path().string());
        }
    }, my_iter);
}

int main(int argc, const char** argv) {
    if (argc < 3) {
        return 1;
    }
    const std::filesystem::path sys_path{ argv[2] };
    const std::string options{ argv[1] };

    std::vector<std::string> files;
    if (options[0]=='-') {
        if (std::filesystem::is_directory(sys_path)) {
            IterVariant file_iterator = option_R(options, sys_path);
            traverse(file_iterator, files);
        }
        std::cout << "after this the program will parse other options\n";
    } else {
        std::cout << "simply print all files\n";
    }

    for (std::string& file_name : files) {
        std::cout << file_name << '\n';
    }

    return 0;
}

    ( exemplo vivo )

    • 2

  2. Você está muito perto. O problema é que você não pode fazer sua option_R()função retornar um tipo de modelo de tempo de compilação que é determinado em tempo de execução. Você precisa fazer com que ela retorne a std::variantsi mesma, e então o chamador pode decidir o que fazer com o valor. Você pode usar std::visit()para ajudar com isso, por exemplo:

    #include <iostream>
#include <vector>
#include <string>
#include <filesystem>
#include <variant>

#include <type_traits>
#include <concepts>

using namespace std;
using namespace std::filesystem;

template<typename T>
concept isDirIter = is_same_v<T, directory_iterator> || is_same_v<T, recursive_directory_iterator>;

using DirIterVariant = variant<directory_iterator, recursive_directory_iterator>;

DirIterVariant option_R(std::string_view options, const path &my_path) {
    if (options.find('R') != string::npos) {
        cout << "Will scan subdirectories recursively" << endl;
        return recursive_directory_iterator(my_path, directory_options::skip_permission_denied);
    } else {
        cout << "Will scan directory only" << endl;
        return directory_iterator(my_path);
    }
}

template <isDirIter dirIterator>
void traverse(dirIterator &my_iter, vector<string> &my_vec) {
    cout << "This function traverses the given dir path, "
        << "stores all filenames found inside a vector." << endl;
    for (const auto &entry : my_iter)
        my_vec.push_back(entry.path().string());
}

int main(int argc, const char **argv) {
    const path sys_path{argv[2]};
    const string options{argv[1]};

    vector<string> files;
    if (options[0] == '-') {
        if (is_directory(sys_path)) {
            DirIterVariant file_iterator_v = option_R(options, sys_path);
            visit([&](auto&& file_iterator) {
                traverse(file_iterator, files);
            },
            file_iterator_v);
        }
        cout << "after this the program will parse other options" << endl;
    } else {
        cout << "simply print all files" << endl;
    }
}
    • 1

relate perguntas