C++；-'；（常量字符*）和#x27；未在范围内声明？ 我想为C++做一个自定义字符串类。但当我这么做的时候： g++ test.cpp sys/Base.h sys/Base.cpp

我得到这个错误：

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

//头文件处理
#伊夫德夫阿拉夫基地
#定义ARAVK_BASE_H
//包括
#包括
//全局变量
#定义退出\u YAY 0
#定义退出错误1
使用名称空间std；
命名空间基{
//课程：
类字符串{
静态常量字符*strval；
公众：
//建造商：
字符串（）；
字符串（char[]）；
字符串（常量字符*）；
弦（弦）；
//析构函数：
~String（）；
//操作员：
// =
void运算符=（常量字符串&）；
void运算符=（常量字符*&）；
void运算符=（常量字符串&）；
//转换：
常量char*toChar（）常量；
字符串toStr（）常量；
};
//职能：
//输入输出：
//写：
空写（字符串）；
空写（字符串）；
无效写入（常量字符*）；
//阅读：
字符串读取（）；
//执行：
字符串运行（字符串）；
}
#恩迪夫

sys/Base.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);
            }

}  

//包括
#包括“Base.h”
#包括
#包括
#包括
#包括
#包括
#包括
#包括
//全局变量
#定义退出错误1
#定义退出\u YAY 0
/* ------------------------ */
使用名称空间std；
命名空间基{
//班级
//字符串函数
//建设者
String:：String（）{
常量字符*strval=“”；
}
字符串：：字符串（常量字符*str）{
常量字符*strval=str；
}
String：：String（String str）{
const char*strval=str.c_str（）；
}
字符串：：字符串（char str[]）{
常量字符*strval=str；
}
//析构函数
字符串：：~String（）{
删除strval；
}
//操作员
// =
无效字符串：：运算符=（常量字符串和strp）{
strval=strp.toChar（）；
}
无效字符串：：运算符=（常量字符*&strp）{
strval=strp；
}
无效字符串：：运算符=（常量字符串和strp）{
strval=strp.c_str（）；
}
//转换：
常量char*toChar（）{
返回strval；
}
字符串toStr（）{
返回字符串（strval）；
}
//职能：
//输入输出：
//写
空写（字符串str）{printf（str.toChar（））；}
空写（const char*str）{printf（str）；}
空写（字符串str）{printf（str.c_str（））；}
//阅读
String read（）{char str[100]；scanf（“%s”，str）；返回字符串（str）；}
//TODO:还有更多
//执行
/*字符串运行（字符串命令）{
const char*cmd=command.toChar（）；
字符缓冲区[128]；
字符串结果=”；
标准：共用管道（popen（cmd，“r”），pclose）；
如果（！pipe）抛出运行时错误（“popen（）失败！”）；
而（！feof（pipe.get（））{
if（fgets（缓冲区，128，pipe.get（））！=NULL）
结果+=缓冲区；
}
返回字符串（结果）；
}*/
字符串运行（字符串命令）{
字符缓冲区[128]；
std:：string result=“”；
const char*cmd=command.toChar（）；
文件*pipe=popen（cmd，“r”）；
如果（！pipe）抛出std:：runtime_错误（“popen（）失败！”）；
试一试{
而（！feof（管道））{
if（fgets（缓冲区，128，管道）！=NULL）
结果+=缓冲区；
}
}捕获（…）{
pclose（管道）；
投掷；
}
pclose（管道）；
返回字符串（结果）；
}
}  

我不知道为什么会这样。我认为这与我如何声明/定义const char*‘strval’有关。有人能帮忙吗？

---

注：如果答案太大，这个项目在Github上：

让我们看看你的构造函数：

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

这声明了一个名为

strval

的局部变量。该变量是构造函数的局部变量；一旦构造函数的执行完成，它就不存在了

相反，您需要的是一个成员变量——在类中声明它，而不是在成员方法或构造函数中声明它。事实上，您已经在头文件中定义了它：

    class String {
            static const char* strval;

因此，从构造函数中删除

const char*

，并添加一个类限定符，以便该行成为对现有变量的赋值，而不是创建局部变量：

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

并更改导致错误的return语句：

              return String::strval;

或者-这可能是您真正想要的-从变量定义中删除

静态

限定符，并将构造函数改为：

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

此外，析构函数错误地

删除了不一定是动态分配的数据，或者可能属于另一个对象的数据：

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

这需要重新工作。目前最简单的解决方案是删除
delete strval

您的
read（）char str[100]; scanf("%s", str); return String(str);

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

static const char* strval