将字符串文字分配给char *：const_cast <char *> 与使用char数组

Question

I'm using some C functions in my C++ environment. And I get the following warnings because C++ doesn't allow assigning string literal to char * type.

C++11 does not allow conversion from string literal to char *

My Code:

void sys_vgui(char *fmt, ...)
{
    va_list ap;
    va_start(ap, fmt);
    //do something
    va_end(ap);
}

void open(t_buf *x)
{ 
    sys_vgui("wm deiconify .x%lx\n", x);
    sys_vgui("raise .x%lx\n", x);
    sys_vgui("focus .x%lx.text\n", x);
}

And I could remove these warnings by const casting the string literals as the following.

sys_vgui(const_cast<char *>("wm deiconify .x%lx\n"), x);
sys_vgui(const_cast<char *>("raise .x%lx\n"), x);
sys_vgui(const_cast<char *>("focus .x%lx.text\n"), x);

But I'm not sure if it's really safe as I've seen many people saying not to directly cast string literal to char * .

So I came up with the following which seems like a safer solution.

char str1[] = "wm deiconify .x%lx\n";
sys_vgui(str1, x);
char str2[] = "raise .x%lx\n";
sys_vgui(str2, x);
char str3[] = "focus .x%lx.text\n";
sys_vgui(str3, x);

But it makes my code dirty and harder to maintain as I have to create multiple variables using different names(eg str1, str2, str3...) whenever I use the function.

So my questions are:

1) Is it really not safe to use const_cast<char *> in my case?

2) Any solution to write a clean code using char arrays without having to create multiple variables using different names?

Answer 1

It is safe as long as sys_vgui does not modify the string, which presumably it doesn't because modifying a string literal has undefined behavior in C, const or not. So if you have something like

sys_vgui("wm deiconify .x%lx\n", x);

in C, then the C++ version with const_cast is just as safe.

However, to de-uglify the C++ code, I'd probably write a wrapper function:

template<typename ...Ts>
void xsys_vgui(const char *fmt, Ts ...args) {
    sys_vgui(const_cast<char *>(fmt), args ...);
}

Now

xsys_vgui("wm deiconify .x%lx\n", x);

should "just work" in C++.

Answer 2

If you really know that sys_vgui doesn't use the passed pointer to modify something, it's fine in practice, although dirty, because that assumption is just in your head.

In c++17 you can use std::string::data :

sys_vgui(std::string{"wm deiconify .x%lx\n"}.data(), x);

Prior to that (in c++11 and c++14 ) you have to specify the size manually to std::array (including null terminator, but the compiler will probably complain anyway if it's wrong)

sys_vgui(std::array<char, 20>{"wm deiconify .x%lx\n"}.data(), x);

Answer 3

Don't abuse the const_cast intentions (and even if not abusing it, try and contrive a way to avoid it in the first place).

This is rather hideous, but may do what you intend: a template version of the API you desire, designed to manufacture the requisite mutable array and forward it appropriately thereafter. For callers actually supplying non-const arrays or pointers, it should just invoke the api directly.

#include <iostream>
#include <algorithm>

void do_function(char *ptr)
{
    std::cout << __PRETTY_FUNCTION__ << '\n';
}

template<size_t N>
void do_function(const char (&ar)[N])
{
    std::cout << __PRETTY_FUNCTION__ << '\n';
    char inside[N];
    std::copy(ar, ar+N, inside);
    do_function(inside+0);
}

int main()
{
    char msg[] = "array test";
    do_function(msg);

    do_function("Something const");
    do_function("Nothing");
}

Output

void do_function(char *)
void do_function(const char (&)[N]) [N = 16]
void do_function(char *)
void do_function(const char (&)[N]) [N = 8]
void do_function(char *)

Note: I've not really put this through the wringer, but it will likely achieve what you desire. This biggest bonus is you need not change any of the prior calls (beyond removing those const_cast misnomers). the original calls passing string literals will simply start working. All you need to is hang the template version and let the compiler sort out the rest.

Answer 4

If you do not want to change sys_vgui then you can make a wrapper:

template<typename... Args>
void sys_vgui_c(char const *fmt, Args&&... args)
{
     sys_vgui( const_cast<char *>(fmt), args... );
}

and then call it with the string literal: sys_vgui_c("wm deiconify .x%lx\\n", x);

Answer 5

How about a variadic macro:

#include <stdio.h>
#include <stdarg.h>
#include <string.h>

#define my_vgui(fmt_,...) \
    do { \
        char myfmt[strlen(fmt_) + 1]; \
        strcpy(myfmt,fmt_); \
        sys_vgui(myfmt,##__VA_ARGS__); \
    } while (0)

void
sys_vgui(char *fmt,...)
{
    va_list ap;

    va_start(ap,fmt);
    fmt[0] |= 0;
    vprintf(fmt,ap);
    va_end(ap);
}

int
main(void)
{

    my_vgui("hello\n");
    my_vgui("hello %s\n","world");

    return 0;
}

Note that there may be cleaner ways to do the macro, so see: https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html