Invalid conversion from ‘const char*’ to ‘unsigned char*’

Un simple code C++:

int main(){
unsigned char* t="123";
}

sur la compilation avec g++ donne l'erreur suivante:

invalid conversion from ‘const char*’ to ‘unsigned char*’ [-fpermissive]

Pourquoi?

Parce qu'un littéral de chaîne est const.
Merci. Alors, comment le résoudre? Outre l'utilisation de std::string
Et oui, si c'est une chaîne littérale, gcc ne donne pas d'erreur sur ce point.
Si vous voulez dire que l'utilisation d'un compilateur C ne donne pas une erreur, c'est (en partie) parce que, dans C , "123" a type char[4] alors qu'en C++, elle est de type const char[4]. gcc , si ce n'est invoquée dans le mode standard, permet également la conversion entre les char * et unsigned char * sans un casting

OriginalL'auteur anupamD | 2015-12-26

  1. 22

    En C++ littéraux de chaîne ont des types de constant des tableaux de caractères. Par exemple littéral de chaîne "123" a type const char[4].

    Dans les expressions avec de rares exceptions, les tableaux sont convertis à des pointeurs de leurs premiers éléments.

    Donc dans cette déclaration

    unsigned char* t="123";

    l'initialiseur de type const char *. Il n'y a pas de conversion implicite de const char * à unsigned char *

    Vous pouvez écrire

    const unsigned char* t = reinterpret_cast<const unsigned char *>( "123" );
    Grâce gcc gère d'une manière différente alors.
    Il est préférable de suivre la norme au lieu d'utiliser des extensions de langage du compilateur.:)
    L'initialiseur de type const char[4]

    OriginalL'auteur Vlad from Moscow

  2. 3

    Une autre approche, qui vous procure un modifiable unsigned char tableau que vous vouliez à l'origine, est:

    #include <cstdlib>
#include <iostream>

using std::cout;
using std::endl;

int main()
{
    unsigned char ta[] = "123";
    unsigned char* t = ta;

    cout << t << endl;  //Or ta.

    return EXIT_SUCCESS;
}

    Vous pouvez ajouter const pour les deux déclarations si vous le souhaitez, pour obtenir const unsigned char sans un cast explicite.

    OriginalL'auteur Davislor

  3. 1

    Les Conversions d'un type vers un autre type est facile lorsque vous utilisez des macros définies. Donc, ici, est un ensemble de macros que vous pouvez utiliser sur n'importe quelle plateforme (Windows, Linux, Solaris, AIX, etc...)

    #define M_ToCharPtr(p)        reinterpret_cast<char*>(p)                   //Cast to char*
#define M_ToWCharPtr(p)       reinterpret_cast<wchar_t*>(p)                //Cast to wchar_t*
#define M_ToConstCharPtr(p)   reinterpret_cast<const char*>(p)             //Cast to const char*
#define M_ToConstWCharPtr(p)  reinterpret_cast<const wchar_t*>(p)          //Cast to const wchar_t*
#define M_ToUCharPtr(p)       reinterpret_cast<unsigned char*>(p)          //Cast to unsigned char*
#define M_ToConstUCharPtr(p)  reinterpret_cast<const unsigned char*>(p)    //Cast to const unsigned char*
#define M_ToUCharPtr(n)       reinterpret_cast<unsigned char*>(n)          //Cast to unsigned char*
#define M_ToVoidPtr(p)        reinterpret_cast<void*>(p)                   //Cast to void*
#define M_ToConstVoidPtr(p)   reinterpret_cast<const void*>(p)             //Cast to const void*
#define M_ToIntPtr(n)         reinterpret_cast<int*>(n)                    //Cast to int*
#define M_ToConstIntPtr(p)    reinterpret_cast<const int*>(p)              //Cast to const int*
#define M_ToDoublePtr(n)      reinterpret_cast<double*>(n)                 //Cast to double*
#define M_ToConstDoublePtr(n) reinterpret_cast<const double*>(n)           //Cast to const double*
#define M_ToBoolPtr(n)        reinterpret_cast<bool*>(n)                   //Cast to bool*
#define M_ToConstBoolPtr(n)   reinterpret_cast<const bool*>(n)             //Cast to const bool*
//General Cast
#define M_To(T, p)            reinterpret_cast<T>(p)                       //Cast to T

    Dans votre cas

    const unsigned char* t = reinterpret_cast<const unsigned char *>("UCHAR TO CONST UCHAR");

    est équivalent à 

    const unsigned char* t = M_ToConstUCharPtr("UCHAR TO CONST UCHAR");
    Ces macros ne sont pas beaucoup plus court et seulement obfusquer le code.
    Pourquoi en bas de vote? Si elle est mauvaise, alors il est acceptable, mais je vais essayer d'aider les programmeurs qui veulent utiliser des macros dans les conversions. Ce n'est pas un must pour l'utilisation de macros, plutôt que n'importe qui peut utiliser le long des littéraux...

    OriginalL'auteur SajithP

  4. 0

    Simplement utiliser

    1. juste char* à la place de unsigned char* lors de la déclaration de

    2. char t[MAX_SIZE] = "123"; //MAX_SIZE doit être défini précédemment

    3. le temps de tester strcpy() et strncpy fonctions

    OriginalL'auteur malang