C++ - '(const char *)' nicht im Geltungsbereich deklariert?

Question

Ich möchte eine benutzerdefinierte String-Klasse für C++ machen. Aber wenn ich dies tun:

g++ test.cpp sys/Base.h sys/Base.cpp 

ich diesen Fehler:

sys/Base.cpp: In function 'const char* Base::toChar()': 
sys/Base.cpp:57:13: error: 'strval' was not declared in this scope 
     return strval; 
      ^
sys/Base.cpp: In function 'std::string Base::toStr()': 
sys/Base.cpp:60:20: error: 'strval' was not declared in this scope 
     return string(strval); 
        ^

test.cpp

#include "sys/Base.h" 
int main() { 
    Base::write("Hello there.\n"); 
    return 0; 
} 

sys/base.h

// Header file handling 
#ifndef ARAVK_BASE_H 
#define ARAVK_BASE_H 

// Includes 
#include <string> 

// Global variables 
#define EXIT_YAY 0 
#define EXIT_ERR 1 

using namespace std; 

namespace Base { 
    // Classes: 
     class String { 
       static const char* strval; 
      public: 
       // Constructors: 
        String(); 
        String(char[]); 
        String(const char*); 
        String(string); 
       // Destructors: 
        ~String(); 

       // Operators: 
        // = 
         void operator=(const String&); 
         void operator=(const char*&); 
         void operator=(const string&); 

       // Conversion: 
        const char* toChar() const; 
        string toStr() const; 
     }; 
    // Functions: 
     // Input-Output: 
      // Write: 
       void write(String); 
       void write(string); 
       void write(const char*); 
      // Read: 
       String read(); 

     // Executing: 
      String run(String); 
} 
#endif 

sys/Basis .cpp

// Including 
#include "Base.h" 
#include <string> 
#include <stdio.h> 
#include <stdlib.h> 
#include <cstdio> 
#include <iostream> 
#include <memory> 
#include <stdexcept> 

// Global variables 
#define EXIT_ERR 1 
#define EXIT_YAY 0 

/* ------------------------ */ 
using namespace std; 

namespace Base { 
    // Classes 
     // String functions 
      // Constructors 
       String::String() { 
        const char* strval = ""; 
       } 
       String::String(const char* str) { 
        const char* strval = str; 
       } 
       String::String(string str) { 
        const char* strval = str.c_str(); 
       } 
       String::String(char str[]) { 
        const char* strval = str; 
       } 
      // Destructors 
       String::~String() { 
        delete strval; 
       } 
      // Operators 
       // = 
        void String::operator=(const String &strp) { 
         strval = strp.toChar(); 
        } 
        void String::operator=(const char* &strp) { 
         strval = strp; 
        } 
        void String::operator=(const string &strp) { 
         strval = strp.c_str(); 
        } 
      // Conversion: 
       const char* toChar() { 
        return strval; 
       } 
       string toStr() { 
        return string(strval); 
       } 

    // Functions: 
     // Input-Output: 
      // Write 
       void write(String str)  { printf(str.toChar()); } 
       void write(const char* str) { printf(str);    } 
       void write(string str)  { printf(str.c_str()); } 
      // Read 
       String read()      { char str[100]; scanf("%s", str); return String(str); } 
       //TODO: More to come 

     // Executing 
      /*String run(String command) { 
       const char* cmd = command.toChar(); 
       char buffer[128]; 
       string result = ""; 
       std::shared_ptr<FILE> pipe(popen(cmd, "r"), pclose); 
       if (!pipe) throw runtime_error("popen() failed!"); 
       while (!feof(pipe.get())) { 
        if (fgets(buffer, 128, pipe.get()) != NULL) 
         result += buffer; 
       } 
       return String(result); 
      }*/ 
      String run(String command) { 
       char buffer[128]; 
       std::string result = ""; 
       const char* cmd = command.toChar(); 
       FILE* pipe = popen(cmd, "r"); 
       if (!pipe) throw std::runtime_error("popen() failed!"); 
       try { 
         while (!feof(pipe)) { 
           if (fgets(buffer, 128, pipe) != NULL) 
             result += buffer; 
         } 
       } catch (...) { 
         pclose(pipe); 
         throw; 
       } 
       pclose(pipe); 
       return String(result); 
      } 

} 

Ich bin mir nicht sicher, warum das passiert. Ich denke, es hängt damit zusammen, wie ich das const char * 'strval' deklariert/definiert habe. Kann jemand helfen? P. S: Wenn die Antwort zu groß ist, ist dieses Projekt auf Github: AravK/C-Applications

Answer 1

Lassen Sie uns einen Blick auf Ihre Konstruktor nehmen:

  String::String() { 
       const char* strval = ""; 
      } 

Dies erklärt eine lokale Variable strval genannt. Die Variable ist lokal für den Konstruktor; Es existiert nicht, sobald die Ausführung des Konstruktors abgeschlossen ist.

Was Sie stattdessen benötigen, ist eine Membervariable - deklarieren Sie es innerhalb der Klasse, aber nicht innerhalb einer Member-Methode oder Konstruktor. In der Tat haben Sie es bereits als solche in der Header-Datei definiert:

class String { 
      static const char* strval; 

Also, die const char * von Ihrem Konstruktor entfernen und eine Klasse-Qualifikation hinzuzufügen, so dass die Leitung eine Zuweisung an die bestehenden Variable wird, anstatt Schaffung eines lokalen:

  String::String() { 
       String::strval = ""; 
      } 

Und auch die return-Anweisung ändern, die Sie den Fehler geben:

   return String::strval; 

Oder vielleicht - , und dies ist wahrscheinlich, was Sie wirklich wollte - den static Qualifier aus der Variablendefinition und den Konstruktor ändern stattdessen nur:

  String::String() { 
       strval = ""; 
      } 

Darüber hinaus Ihre destructor falsch delete s Daten, die nicht notwendigerweise dynamisch zugewiesen wurde, oder die zu einem anderen Objekt gehören können:

  String::~String() { 
       delete strval; 
      } 

Dies erfordert eine Überarbeitung. Im Moment ist die einfachste Lösung, die delete strval insgesamt zu entfernen.

Ihre read() Funktion stiftet möglicherweise einen Pufferüberlauf, durch scanf mit ("% s") mit einer festen Größe Puffer und unbekannten Eingangsgröße:

char str[100]; scanf("%s", str); return String(str); 

Schließlich Befehlszeile:

g++ test.cpp sys/Base.h sys/Base.cpp 

... sollte nicht enthalten die Header-Datei (Base.h). Sie geben die Einheiten an, die Sie kompilieren möchten, und Base.h ist bereits in Base.cpp enthalten. es ist keine eigenständige Einheit, die inkompiliert werden sollte.

Answer 2

ja Sie haben die Variable in Ihrer Klasse nicht als Feld definiert. gibt es 3 Einheimische Deklaration in Ihren Konstruktoren. fügen Sie es einfach so hinzu, wie Sie es in der Kopfzeile getan haben.

static const char* strval 

und entfernen Sie die Definition in Ihren Konstruktoren. Behalte einfach den Aufgabenbereich. Grüße