从'const char**'到'char* const*'的转换无效

Invalid conversion from 'const char**' to 'char* const*'

本文关键字：char const 无效 转换      更新时间：2023-10-16

我正在做一个学校作业，我必须调用execvp，其方法签名如下

execvp(const char* file, char* const argv[])

但是，我的数据形式为：

std::vector<std::string*>

我一直在尝试将所述向量转换为第二种格式的正确格式execvp()，但不可避免地出现以下错误：

command.cc:120:29: error: invalid conversion from ‘const char**’ to ‘char* const*’ [-fpermissive]
execvp(args[0], argv);

我尝试了不同的变体，但它们都会导致此错误。这个错误让我感到困惑，因为我不知道const*是什么意思。你怎么能有const*？我会考虑将std::vector更改为其他类型的，但这是一项任务，我真的不允许更改它。以下是我用来尝试从向量创建char*[]的代码：

const size_t numArgs = _simpleCommands[i]->_arguments.size();
std::vector<const char*> args;
for(size_t j = 0; j < numArgs; ++j)
{
args.push_back(strPtrToCharPtr(_simpleCommands[i]->_arguments[i]));
}
const char** argv = new const char*[numArgs];
for(size_t j = 0; j < numArgs; ++j)
{
argv[j] = args[j];
}
execvp(args[0], argv);

char* const argv[]原型意味着argv是指向char的指针数组(地址)，数组中的指针不能被修改，但它们指向的字符串可以修改。 这与char const **不同，后者是指向字符无法修改char的指针。 由于将其传递给可能修改数组中字符串的函数会违反const char **的const限定符，因此不允许这样做。 (你可以用const_cast来做到这一点，但那会解决错误的问题。

由于execvp()是一个非常古老的UNIX函数，并且今天没有相同的接口，因此它没有任何参数来告诉操作系统有多少参数，也不承诺不修改数组中字符串的内容。 通过将最后一个元素设置为NULL来终止数组。

它的格式类似于main()的argv参数。 事实上，如果它是用 C 编写的，它就会成为您运行的程序的main()函数的argv参数。

这不是一个完整的解决方案，因为这是一个家庭作业，你想自己解决它，但你必须自己创建那个数组。 为此，您可以创建一个std::vector<char *> argv( args.size() + 1 )，将每个元素(最后一个元素除外)设置为args相应元素的.data()指针，并将最后一个元素设置为NULL。 然后，argv.data()传递给execvp()。

请注意，POSIX.1-2008 标准说，

指针的argv[]和envp[]数组以及这些数组指向的字符串不得通过调用其中一个 exec 函数来修改，除非是替换进程映像的结果。

因此，如果你不介意危险地生活，你应该能够摆脱数组中字符串的const，这一次。 通常，您需要为数组中的每个常量字符串创建一个可修改的副本。

更新

时间已经过去了，我没有给出家庭作业的答案。 一位评论者声称我的答案不适用于 g++8，这意味着他们没有实现我所想到的相同算法。 因此，发布完整的解决方案将很有帮助。

这实际上解决了如何转换std::vector<std::string>以与execvp()一起使用的密切相关的问题。 (std::vector<std::string*>基本上永远不正确，当然在这里也不对。 如果您真的想要一个，请更改for循环中的s类型并取消引用。

#define _XOPEN_SOURCE   700
// The next three lines are defensive coding:
#define _POSIX_C_SOURCE 200809L
#define _XOPEN_VERSION  700
#define _XOPEN_UNIX     1
#include <errno.h>
#include <stdlib.h>
#include <string>
#include <unistd.h>
#include <vector>
int main()
{
const std::vector<std::string> cmdline{ "ls", "-al" };
std::vector<const char*> argv;
for ( const auto& s : cmdline ) {
argv.push_back( s.data() );
}
argv.push_back(NULL);
argv.shrink_to_fit();
errno = 0;
/* Casting away the const qualifier on the argument list to execvp() is safe
* because POSIX specifies: "The argv[] [...] arrays of pointers and the
* strings to which those arrays point shall not be modified by a call to
* one of the exec functions[.]"
*/
execvp( "/bin/ls", const_cast<char* const *>(argv.data()) );
// If this line is reached, execvp() failed.
perror("Error executing /bin/ls");
return EXIT_FAILURE;
}

另一个转折是编写一个转换函数，该函数返回包含命令行参数的std::vector<const char*>。 这同样有效，这要归功于有保证的复制省略。 我通常喜欢使用 RIIA 和静态单个赋值进行编码，因此我发现返回一个生命周期自动管理的对象更优雅。在这种情况下，argv的元素是对cmdline中字符串的弱引用，所以cmdline必须比argv长寿。 因为我们使用 C 样式指针作为弱引用，所以 RIIA 在这里不太有效，我们仍然需要注意对象生存期。

#define _XOPEN_SOURCE   700
#define _POSIX_C_SOURCE 200809L
#define _XOPEN_VERSION  700
#define _XOPEN_UNIX     1
#include <errno.h>
#include <stdlib.h>
#include <string>
#include <unistd.h>
#include <vector>
std::vector<const char*> make_argv( std::vector<std::string>const& in )
{
std::vector<const char*> out;
out.reserve( in.size() + 1 );
for ( const auto& s : in ) {
out.push_back( s.data() );
}
out.push_back(NULL);
out.shrink_to_fit();
return out; // Benefits from guaranteed copy elision.
}
int main()
{
const std::vector<std::string> cmdline{ "ls", "-al" };
errno = 0;
/* Casting away the const qualifier on the argument list to execvp() is safe
* because POSIX specifies: "The argv[] [...] arrays of pointers and the
* strings to which those arrays point shall not be modified by a call to
* one of the exec functions[.]"
*/
execvp( "/bin/ls", const_cast<char* const *>(make_argv(cmdline).data()) );
// If this line is reached, execvp() failed.
perror("Error executing /bin/ls");
return EXIT_FAILURE;
}

我不明白std::vector<std::string *>部分(你确定你不需要std::vector<std::string>吗？

const规则：它应用于左侧的元素;如果左侧没有元素，则应用于右侧的元素。

因此，const char**(或char const **，如果您愿意)是指向常量char的指针。我的意思是：常量部分是指向的char，而不是指针。

char * const *是指向char的常量指针的指针;在这种情况下，常量部分是两个指针之一，而不是指向char。

在您的情况下，函数

execvp(const char* file, char* const argv[])

期望，作为第二个参数，一个char * const argv[](一个指向char的常量指针的 C 样式数组)，您可以将其视为char * const *。

但是你打电话

execvp(args[0], argv);

其中argv是char const **，那与char * const *不同。

所以错误：该函数期望能够修改指向的char，并且您将指针传递给指向不可修改char的指针

而且您不能将argv定义为char * const *

char * cont * argv = new char * const [numArgs]; // <-- WRONG

因为您无法修改它。

因此，为了解决这个问题，我想您可以将argv定义为char **

char** argv = new char* [numArgs];
for(size_t j = 0; j < numArgs; ++j)
argv[j] = args[j];
execvp(args[0], argv);

如果您将一个非常量对象传递给需要常量对象的函数，则没有问题(相反可能是一个问题)，因此您可以将char **传递给期望char * const *的函数。

1)你不需要const *(常量指针)，因为如果需要，指针会自动转换为常量指针;

2)但是你确实需要提供char*(不是const char*！)数组作为execvp的第二个参数，即你的字符串字符应该是可修改的。通过拥有这样的签名，execvp 保留修改提供的参数字符串的权利(是的，这看起来很奇怪 - 但进程确实有权更改其参数 - 请注意，main()例程可能有(非常量)char** argv参数！因此，您需要摆脱代码段中的const char*并用char *替换它们

相关文章：