C++ 错误：在'；之前出现意外的非限定id'；代币

我试图制作一个充满O字符的矩阵，但我对类是新手。 尝试运行时，我遇到以下错误：

错误：“.”标记之前出现意外的非限定id

我在班上做错了什么，但我不知道是什么。 有人有主意吗

#include <iostream>

using namespace std;

class field
    {

private:

public:
    char** the_field;
    int i, j;
    char**  create_field(void);
    void    print_field();

    };

////////// CREATE THE FIELD //////////

  char** field::create_field(void) //define member function
   {

        for(int i = 0; i < 14; i++)
        {
            the_field[i] = new char [14];

            for(int j = 0; j < 14; j++)
            {
                the_field[i][j] = 'O';
            }
        }
        return the_field;
   }
//////////// PRINT THE FIELD //

    void field::print_field()
    {
        for(int i = 0; i < 14; ++i)
        {
            for(int j = 0; j < 14; ++j)
            {
                cout << " " << the_field[i][j] << " ";
            }
 //             putchar('\n');
            cout<<"\n";
        }
    }

int main()
{
//declare objects with type field
field create_field; //declare create_field as type of field
field print_field;
int i, j;

field.create_field();
field.print_field();

 return 0;
 }

#包括
使用名称空间std；
类字段
{
私人：
公众：
字符**_字段；
int i，j；
字符**创建_字段（无效）；
无效打印_字段（）；
};
//////////创建字段//////////
char**field:：create_field（void）//定义成员函数
{
对于（int i=0；i<14；i++）
{
_字段[i]=新字符[14]；
对于（int j=0；j<14；j++）
{
_字段[i][j]=“O”；
}
}
返回_字段；
}
////////////打印字段//
void字段：：print_字段（）
{
对于（int i=0；i<14；++i）
{
对于（int j=0；j<14；++j）
{
有多少字段？我想你想要一个字段，但你已经声明了两个。我想你想要这个

field my_field;

my_field.create_field();
my_field.print_field();

顺便说一句，我想你会同意，如果你的成员函数被调用为
create
和
print
，那么这段代码的可读性会更好。一般来说，我不认为按照成员函数所属的类来命名成员函数是个好主意。
你的代码中有很多问题：


如果你用new创建了一些东西，你还必须对这个对象调用delete
_字段应该是私有的
您不需要在类中定义i和j，因为它们已经在for循环中定义了
您忽略了create_field（）方法返回的内容
网格的大小不是动态的（在类似情况下使用宽度和高度）
_字段是指向指针的指针（在您的例子中是2D数组），但您只创建了列（还必须创建行）


我给你修好了，请试试

    #include <iostream>

    using namespace std;


    class field
    {
    private:
        char** the_field;
        int width;
        int height;

    public:
        // constructor
        field(int w, int h);

        // destructor
        ~field();

        // method
        void print();
    };



    field::field(int w, int h)
    {
        width = w;
        height = h;

        the_field = new char*[width];
        for (int i=0; i<width; i++)
        {
            the_field[i] = new char[height];
            for (int j=0; j<height; j++)
            {
                the_field[i][j] = 'O';
            }
        }
    }


    field::~field()
    {
        for (int i=0; i<width; i++)
            delete[] the_field[i];

        delete[] the_field;
    }


    void field::print()
    {
        for(int i=0; i < width; i++)
        {
            for(int j=0; j < height; j++)
            {
                cout << " " << the_field[i][j] << " ";
            }
            cout << "\n";
        }
    }



    int main()
    {
        field* myfield = new field(14, 14);
        myfield->print();
        delete myfield;

        return 0;
    }

#包括
使用名称空间std；
类字段
{
私人：
字符**_字段；
整数宽度；
内部高度；
公众：
//建造师
字段（int w，int h）；
//析构函数
~field（）；
//方法
作废打印（）；
};
字段：：字段（整数w，整数h）
{
宽度=w；
高度=h；
_字段=新字符*[宽度]；
对于（int i=0；i您正在使用类名。“.”运算符用于类的对象访问其属性。
如果您这样做：

字段对象；

对象。创建_字段（）；

那你就不会有问题了。
“非限定id”表示您没有为其提供有效标识符。
而你没有，因为你使用了类名而不是对象的标识符

field.create_field();

应该是

create_field.create_field();

等等

您正在创建两个类型为
字段
的变量，其名称与
字段
类的成员函数相同。虽然非常合法，但它非常混乱，可能不是您想要的

field.create_field();
field.print_field();

这是不正确的代码，因为必须在类的实例上调用非静态成员函数，但您正试图直接在类上调用它们。如果它们是
静态的
，您可以这样做，但您必须使用
：
而不是

不过，这可能不是您想要的。我假设您想要创建一个
字段
对象，然后在其上调用成员函数。代码如下：

field fieldInstance;
fieldInstance.create_field();
fieldInstance.print_field();


关于设计的旁注：


一般来说，遵循类封装的原则是一个好主意。这意味着数据成员不应该是公共的，它们应该隐藏在访问器之下

没有什么理由在成员函数名中重复类名——它们首先是类的一部分

将对象创建与其初始化分开通常是个坏主意。
create\u field（）
的代码最好作为
字段的构造函数

<> >最好避免在C++中进行手动内存分配。一般使用<代码> STD:：向量比手动分配动态数组要优越得多。

创建打印功能时，最好传入一个流对象，以便可以轻松重定向打印


总之，我会这样设计您的类：

class field
{
    std::vector<std::vector<char> > the_field;

public:
    field();
    const std::vector<std::vector<char> >& getField() const { return the_field; }
    void print(std::ostream &stream) const;
}

field::field() :
    the_field(14, std::vector<char>(14, 'O'))
{}

void field::print(std::ostream &stream) const
{
    for (size_t i = 0; i < the_field.size(); ++i) {
        for (size_t j = 0; j < the_field[i].size(); ++j) {
            stream << ' ' << the_field[i][j] << ' ';
        }
        stream << '\n';
    }
}

类字段
{
std：：向量_字段；
公众：
字段（）；
const std:：vector&getField（）const{返回_字段；}
无效打印（标准：：ostream&stream）常数；
}
字段：：字段（）：
_字段（14，std:：vector（14，'O'））
{}
无效字段：：打印（标准：：ostream&stream）常量
{
for（size_t i=0；i流不要浪费我们的时间，错误消息说明了错误发生的行号，请将我们指向该行。除了编译器错误外，您还有一个更严重的运行时错误。您实际上没有分配
_字段
，因此访问
_字段[i]
will是未定义的行为，可能会导致崩溃。除非您需要使用指针，否则您应该使用或可能使用。谢谢您，它现在确实给出了一个运行时错误。我将对此进行研究。我从您的代码中学到了很多，它的结构非常清晰。非常有用。感谢您的努力！它使我阅读的教程更详细ar.如果你真的很满意，别忘了投票并接受答案，这样其他人会很容易注意到正确的答案。好的，我不知道答案按钮。一旦我有足够的声誉点数允许我投票，我就会投票给你的答案：p再次感谢！
class field
{
    std::vector<std::vector<char> > the_field;

public:
    field();
    const std::vector<std::vector<char> >& getField() const { return the_field; }
    void print(std::ostream &stream) const;
}

field::field() :
    the_field(14, std::vector<char>(14, 'O'))
{}

void field::print(std::ostream &stream) const
{
    for (size_t i = 0; i < the_field.size(); ++i) {
        for (size_t j = 0; j < the_field[i].size(); ++j) {
            stream << ' ' << the_field[i][j] << ' ';
        }
        stream << '\n';
    }
}