Início / coding / Perguntas / 79250605
Accepted
Harry
Asked: 2024-12-04 17:48:38 +0800 CST

Como passar um ponteiro duplo como um argumento de ponteiro duplo const

  • 772

Como passar um ponteiro duplo não constante como parâmetro constante para outra função?

Meu código:

#include <iostream>
    
void food(const char** begin, const char** end) {
    
}
    
int main(int argc, char** argv) {
    food(argv, argv + argc);    
}

O erro que recebo:

<source>: In function 'int main(int, char**)':
<source>:8:10: error: invalid conversion from 'char**' to 'const char**' [-fpermissive]
    8 |     food(argv, argv + argc);
      |          ^~~~
      |          |
      |          char**
<source>:3:24: note:   initializing argument 1 of 'void food(const char**, const char**)'
    3 | void food(const char** begin, const char** end) {
      |           ~~~~~~~~~~~~~^~~~~
<source>:8:21: error: invalid conversion from 'char**' to 'const char**' [-fpermissive]
    8 |     food(argv, argv + argc);
      |                ~~~~~^~~~~~
      |                     |
      |                     char**
<source>:3:44: note:   initializing argument 2 of 'void food(const char**, const char**)'
    3 | void food(const char** begin, const char** end) {
      |
c++

3 respostas

  1. As outras respostas explicam seu problema imediato.

    Aqui eu gostaria de demonstrar uma alternativa (já mencionada em um comentário acima ):

    Já que você está usando C++, transforme argc+argv (que na verdade são um legado de C) em um C++ std::vectorde std::strings.

    Usar contêineres e strings padrão é muito mais idiomático em C++ do que usar arrays C simples e arrays C char.

    #include <vector>
#include <string>
#include <iostream>

void food(std::vector<std::string> const & args) {
    // Print args:
    for (auto const& arg : args) {
        std::cout << arg << "\n";
    }
}

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

    // Build a `std::vector<std::string>`:
    std::vector<std::string> args(argv, argv+argc);

    // Call `food`:
    food(args);
}

    Demonstração ao vivo

    • 4

  2. solução 1: make maintake a const char**(nota: pode não ser possível quando mainé sequestrado, como feito pelo SDL).

    void food(const char** begin, const char** end) {

}

int main(int argc, const char** argv) {
    food(argv, argv + argc);    
}

    solução 2: crie outro const char*interior mainque você possa modificar.

    void food(const char** begin, const char** end) {

}

int main(int argc, char** argv) {
    const char* begin = *argv;
    const char* end = *(argv + argc);
    food(&begin, &end);    
}

    Seu código original não pode ser compilado porque dentro dele foodeu poderia definir *beginum const char*armazenado na memória somente leitura, então no seu mainvocê terá um char*apontando para um const charque não estará correto.

    criar um novo begine endque já esteja const char*evita esse problema, pois quaisquer alterações neles não invalidarão argv.

    • 2
  3. Best Answer

    Em C++ e C, podemos atribuir a type*a a const type*. Este não é o caso aqui, no entanto - o problema neste caso é que o constqualificador do parâmetro de função não pertence ao ponteiro-para-ponteiro, mas ao "dado ponteiro-para-apontado".

    Também argv está estritamente falando apontando para a memória de leitura/escrita, embora escrever nela seja uma prática questionável.

    Podemos contornar isso adicionando ponteiros no lado do chamador:

    int main(int argc, char** argv) {
    const char* begin = *argv;
    const char* end   = *(argv + argc);
    food(&begin, &end);    
}

    Aqui *argvdá um char*para os dados e podemos atribuir isso a um somente leitura const char*. E então passar um ponteiro para aquele em vez disso.

    • 2

relate perguntas