Echec de la compilation très simple sous Solaris 10

Question

Je suis dans une boîte Solaris 10. Le compilateur que j'utilise est: /opt/solstudio12.2/bin/CC

La compilation du fichier illustré ci-dessous (myTest2.C) échoue.

% CC -I. -o myTest2 myTest2.C 
"myTest2.C", line 30: Error: "{" expected instead of "myFunc". 
"myTest2.C", line 33: Error: "{" expected instead of "myFunc". 
2 Error(s) detected. 

1. Pourquoi est-il une erreur d'appeler myFunc() tout en déclarant une variable?
2. Est-ce parce que ce n'est pas dans n'importe quelle fonction?
3. Comment se déplacer?

Pour votre information, je vous écris une chaîne obfuscater qui traverse les lignes de code C++ et remplace les instances d'une chaîne entre guillemets (exemple: « myString ») avec un appel de fonction (Exemple: scrambleString (« myString »)) . myFunc dans cet exemple est analogue à scrambleString

---

#include <iostream> 
#include <string> 



using namespace std; 


char* myFunc(string inString) 
{ 
    char outString[1024]; 
    int i; 
    for (i = 0; i <= inString.size()-1; i++) 
     outString[i] = inString[i]; 
    outString[i+1] = '\0'; 
    return outString; 
} 



// This Works: 
static char myVariable1 [ ] = "MyString1" ; 

// This Breaks: 
static char myVariable2 [ ] = myFunc("MyString2") ; // Line #30 

// This Breaks: 
char myVariable5 [1024] = myFunc("MyString3"); // Line 
#33 





int main() 
{ 
    // This Works: 
    string Z = myFunc("Gdkkn Vnqkc"); 
    cout << "Z = " << Z << endl << endl;  
} 

Answer 1

Votre code n'est pas sûr, car le retour Vous êtes en train contenu de la pile, mais à part cela vous retournez un « char * » .. Votre code compiler (mais toujours être dangereux car vous retournez un pointeur vers le contenu sur la pile) si vous modifiez la signature à:

static char *myVariable = myFunc("foo"); 

Cela dit .. Pourquoi ne pas retourner un objet de chaîne au lieu d'utiliser char * ?

Answer 2

Votre code

// This Works: 
static char myVariable1 [ ] = "MyString1" ; 

fonctionne parce qu'une chaîne littérale char à base est un tableau de char. Vous initialisez donc un tableau avec un tableau.

Les quelques lignes,

// This Breaks: 
static char myVariable2 [ ] = myFunc("MyString2") ; // Line #30 

ne fonctionnent pas, parce que vous êtes l'initialisation d'un tableau de char avec un pointeur char*. Un tableau doit être initialisé avec un tableau. La notation des accolades est commune, et c'est ce que votre compilateur se plaint qu'il s'attend à la place d'un appel de fonction.

Si vous souhaitez que certaines variables de chaînes globales soient initialisées par des appels de fonction, pensez à utiliser les fonctions std::string et/ou singleton. Par exemple,

static std::string& myVariable2() 
{ 
    static std::string theString = myFunc("MyString2"); 
    return theString; // Return a reference to the string instance. 
} 

Cependant, ceci est une solution technique à une mauvaise conception, donc je ne suis que recommander comme une solution purement technique au problème actuel.

Essayez plutôt d'éviter les variables globales. .

Vive & HTH,

Answer 3

fonction 1.Your

char* myFunc(string inString) 
{ 
    char outString[1024]; 
    int i; 
    for (i = 0; i <= inString.size()-1; i++) 
     outString[i] = inString[i]; 
    outString[i+1] = '\0'; 
    return outString; 
} 

a un bug: Vous retournez le pointeur vers une variable locale. après que la fonction retourne, la chaîne outString deviendra hors de portée.peu importe même si vous le déclarez comme une chaîne std ::, vous aurez des ennuis.

2. static char myVariable2 [ ] = myFunc("MyString2") ; // Line #30

Voici la taille de myVariable2 est inconnue au moment de la compilation, donc cela cassera

3. char myVariable5 [1024] = myFunc("MyString3");

Cela donne le message d'erreur:

error: array must be initialized with a brace-enclosed initializer, 

Je pense que le message d'erreur dit tout dans ce cas. Le message d'erreur que vous obtenez "Error: "{" expected instead of "myFunc". " est juste une autre façon de dire la même chose.

4.You proclamons variables globales qui est « généralement » pas une bonne idée