C++ ne peut pas convertir de 'const char*' to 'std::string*'

J'ai ce code ci-dessous et j'obtiens le message d'erreur lors de la compilation:

error: cannot convert 'const char*' to 'std::string*' for argument '1' to 'void sillyFunction(std::string*, int)'

#include <iostream>
#include <string>

using namespace std;
int counter = 0;

void sillyFunction(string * str, int cool=0);

int main(){
    sillyFunction("Cool");
    sillyFunction("Cooler", 1);
    return 0;
}

void sillyFunction(string * str, int cool){
    counter++;
    if (cool){
        for (int i=0; i<counter; i++) cout << *str << endl;
    } else {
        cout << *str << endl;
    }
}

OriginalL'auteur Pwnna | 2011-05-13

  1. 13

    Ne prenez pas votre paramètre en tant que string * essayez simplement à l'aide d'un const string & au lieu

    EDIT:

    std::string et const char* sont de types différents. le std::string a déjà une conversion de littéraux de chaîne (ex: "Cool") à la chaîne réelle de l'objet. Donc, en passant par la chaîne de caractères littérale "Cool" vous êtes dans un sens de passage dans un std::string objet, et non un pointeur vers un.

    La raison, j'ai choisi d'utiliser un const string & est principalement de personnels des pratiques de codage. Ceci minimise la pile de l'utilisation de la mémoire, et puisque vous êtes de passage dans une constante chaîne de caractères littérale, il n'est pas nécessaire pour le paramètre à modifier.

    Aussi, ne pas oublier si vous passez d'un string * que vous n'avez plus besoin de déréférencement dans votre cout:

    if (cool){
    for (int i=0; i<counter; i++) cout << str << endl;
} else {
    cout << str << endl;
}
    Si vous expliciter votre réponse et expliquer pourquoi il devrait le faire, je vais upvote votre réponse.

    OriginalL'auteur Dan F

  2. 3

    changement

    void sillyFunction(string * str, int cool){
   counter++;
    if (cool){
        for (int i=0; i<counter; i++) cout << *str << endl;
    } else {
        cout << *str << endl;
    }
}

    à

    void sillyFunction(const char* str, int cool){
    counter++;
    if (cool){
        for (int i=0; i<counter; i++) cout << str << endl;
    } else {
        cout << str << endl;
    }
}

    OriginalL'auteur Sam Miller

  3. 2

    D'expliquer quel est le problème en fait est...

    Tandis que le compilateur sera heureux de vous organiser une char */C-string pour être "converti" à un std::string par le std::string constructeur, ce n'est pas ce que vous avez demandé.

    Vous avez demandé un pointeur à un existant std::string objet. Par définition, ce qui est passé à votre fonction doit être l'adresse d'un déjà existant std::string (ou descendant) de l'objet.

    Vous devez comprendre les pointeurs comme un type distinct -- votre fonction prend un pointer-to-std::string "objet". Alors qu'un std::string peut être consulté via un pointeur vers std::string, le pointeur lui-même est pas un std::string, ni peut-il être "converti" à un std::string, il ne peut être considéré comme un pointeur de char (ou vice-versa).

    La meilleure alternative est en effet un const référence à un std::string (const std::string &). const, dans ce cas, parce que vous ne faites rien pour modifier la chaîne. Si vous étiez, ce serait une autre affaire, et vous devriez examiner attentivement si vous avez l'intention de l'appelant de voir vos modifications.

    En faisant cela, vous dites que vous voulez une std::string objet (n'oubliez pas, une référence à un objet est l'objet, voir C++ FAQ 8.5 en particulier), ce qui permet au compilateur d'invoquer le constructeur approprié pour créer un std::string pour vous lorsque la fonction est appelée avec un char * (const ou non).

    En même temps, si quelqu'un vous passe un réelle std::string, le constructeur est évitée et vous obtenez la même efficacité que si vous aviez pris un pointer-to-std::string. Win-Win.

    Sinon, bien sûr, vous pouvez simplement prendre une plaine std::string, mais dans ce cas, vous toujours obtenir une copie de la chaîne est passée, si c'est un C-string ou un std::string. Parfois, c'est souhaitable, parfois pas. Dans votre cas, vous ne faites rien, mais de l'impression de la chaîne, la création de la surcharge inutile.

    OriginalL'auteur Nicholas Knight

  4. 1

    Vous pouvez convertir une const char * à un string, mais pas à un string *.

    Peut-être que vous voulez que votre sillyFunction de prendre const référence?

    void sillyFunction(const string &str, int cool){
    counter++;
    if (cool){
        for (int i=0; i<counter; i++) cout << str << endl;
    } else {
        cout << str << endl;
    }
}

    OriginalL'auteur Nick Meyer

  5. 1

    Devrait être

    void sillyFunction(const string& str, int cool=0);

    OriginalL'auteur Marius Bancila

  6. 1

    Si vous allez utiliser des pointeurs pour vos fonctions, vous devez déclarer les chaînes de quelque part. la mémoire doit être alloué. donc, soit déclarer une variable ou d'un appel de nouveau pour créer de la mémoire pour la chaîne.

    int main(){
    string str = "Cool";
    string str2 = "Cooler";
    sillyFunction(&str);
    sillyFunction(&str2, 1);
    return 0;
}

    OriginalL'auteur richmb

  7. 1

    Vous pouvez réaliser ceci en modifiant le prototype:

    void sillyFunction(string const &str, int cool=0);

    char const * pourrait être implicitement converti en temporaire std::string, ce qui pourrait être passés par référence (std::string const &). Il n'y a pas de conversion implicite d'un pointeur (std::string *), c'est pourquoi vous obtenez le message d'erreur.

    Ne devrait-elle pas être const string &str?
    c'est la même chose. C'est juste une question de goût comment écrire cela.

    OriginalL'auteur detunized

  8. 0

    j'ai eu un varier la solution la plus simple pour que l'aide de la chaîne de copie

    char s[20]
    strcpy(s,const char *p);

    dix u got la chaîne pointrd par *p en s...
    il fonctionne..

    OriginalL'auteur dibin_salher