在这种情况下如何解决？语法错误：缺少';'在“ *”节点之前？

时间：2019-05-15 07:19:01

标签： c++ syntax

我浏览了类似的其他问题，似乎找不到相关的原因，这里是我认为相关的代码：（编辑：根据要求包括所有代码）

main.cpp 

#include <iostream>
#include "Pitri.h"


int main()
{
    std::cout << "Hello World!\n"; 
}

Pitri.cpp 

#include "Pitri.h"
#include "node.h"
#include "dood.h"
//#include <cstdlib>
#include <iostream>


Pitri::Pitri()
{
    this->length = 0;
    this->head = NULL;
}


Pitri::~Pitri()
{
}

void Pitri::add(dood data)
{
    node* nnode = new node();
    nnode->data = data;
    nnode->next = this->head;
    this->head = nnode;
    this->length++;
}

void Pitri::remove(node * t, node* p)
{
    if (this->head == t)
    {
        if (t->next == NULL)
            this->head = NULL;
        else
            this->head = t->next;
        t->data.Death();
        free(t);
    }
    else
    {
        if (t->next == NULL)
            p->next = NULL;
        else
            p->next = t->next;
        t->data.Death();
        free(t);
    }
}

void Pitri::printP()
{
    int tallyBr = 0;
    node* head = this->head;
    int i = 1;
    while (head)
    {

    }
}

void Pitri::printS()
{
}

void Pitri::printBL()
{
}

void Pitri::populate(int x)
{
    for (int i = 0; i < x; i++)
    {
        dood* baby = new dood;
        this->add(baby);
    }

}

void Pitri::cycle(int x)
{
    //Initial definition in the event that the head node reproduces
    node* curr = this->head;
    node* mate = this->head->next;

    for (int i = 0; i < x; i++)
    {
        int deaths = 0;
        int births = 0;

        if (head == NULL)
        {
            cout << "Pitri has gone extinct!" << endl;
            break;
        }

        while (curr)
        {
            if (rand() % 100 + 1 <= this->mort && this->mort)
            {
                deaths++;
                remove(curr);
            }
            else if (curr->data.GetAge() == this->ttl && this->ttl)
            {
                deaths++;
                remove(curr);
            }
            else if (rand() % 100 + 1 <= this->birth && this->birth)
            {
                births++;
                add(curr->data.Reproduce(mate->data));
            }
            if (curr->next == NULL)
                break;
            mate = curr;
            curr = curr->next;
        }
    }

}

Pitri.h 

    #pragma once


class Pitri
{
public:
    Pitri();
    ~Pitri();
    int length;
    node *head;

    void add(dood data);
    void remove(node* t);
    void printP();
    void printS();
    void printBL();
    void populate(int);
    void cycle(int);
    int getBB();
    int getBL();
    int getLL();

private:
    int ttl,mort,birth;

};

dood.cpp 

    #include "dood.h"
//#include <stdio.h>
//#include <stdlib.h>
#include <time.h>

bool dood::init = false;

dood::dood()
{
    if (!init)
    {
        //Set time for random seed
        srand(time(0));
        init = true;
    }

    Primary = rand()%2;
    //Set Blue eyes to always have Blue recessive.
    if (Primary == 0)
        Secondary = rand()%2;
    else
        Secondary = 1;
}

dood::dood(int a, int b)
{
    if (!init)
    {
        //Set time for random seed
        srand(time(0));
        init = true;
    }

    Primary = a;
    Secondary = b;

}


dood::~dood()
{
}

void dood::Mutate()
{


    this->Primary = rand()%2;
    //Set Blue eyes to always have Blue recessive.
    if (Primary == 0)
        Secondary = rand()%2;
    else
        Secondary = 1;
}

dood dood::Reproduce(dood donor)
{
    int dPri = donor.GetPrimary();
    int dSec = donor.GetSecondary();
    int bPri, bSec;

    int punitvalue = rand() % 4 + 1;

    //if at least one dood has Brown/Brown...
    if((Primary == 0 && Secondary == 0) || (dPri == 0 && dSec == 0))
    {
        bPri = 0;
        // if other is Br/Br
        if (Secondary == dSec)
            bSec = 0;
        //if other is Br/Bl
        else if (Primary == dPri)
            bSec = punitvalue % 2;
        //if other is Bl/Bl
        else
            bSec = 1;
    }
    else if ((Primary == 1 && Secondary == 1) || (dPri == 1 && dSec == 1))
    {
        bSec = 1;
        if (dPri == Primary)
            bPri = 1;
        else
            bPri = punitvalue % 2;
    }
    else
    {
        if (punitvalue == 4)
        {
            bPri = 1;
            bSec = 1;
        }
        else
        {
            bPri = 0;
            if (punitvalue % 3 == 0)
                bSec = 0;
            else
                bSec = 1;
        }
    }

    dood baby = new dood(bPri, bSec);

    return baby;
}

void dood::Death()
{

}

void dood::Age()
{
    age = age + 1;
}

int dood::GetPrimary()
{
    return this->Primary;
}

int dood::GetSecondary()
{
    return this->Secondary;
}

int dood::GetAge()
{
    return age;
}

dood.h 

   #pragma once
class dood
{
public:
    dood();
    dood(int, int);
    ~dood();
    void Mutate();
    dood Reproduce(dood);
    void Death();
    void Age();
    int GetPrimary();
    int GetSecondary();
    int GetAge();

private:
    // Genetec Traits "0" for brown, "1" for Blue
    int Primary;
    int Secondary;
    int age=0;
    //Has rand() been seeded?
    static bool init;

};

node.cpp 

#include "node.h"



node::node()
{
}


node::~node()
{
}

node.h 

#pragma once
class node
{
public:
    node();
    ~node();
    node* next;
    dood data;
};

我没有在人们看到的最常见问题的任何地方使用namespace.std，并且在其他任何地方都未预定义AFAIK节点吗？我可以找到方向吗？

2 个答案:

答案 0 :(得分：0)

感谢WhozCraig，完成我的Pitri类所需的简单解决方法包括：

#include "node.h"
#include "dood.h"

在头文件中，而不在CPP文件中。

答案 1 :(得分：0)

您不能正确地连接从属标头，更糟糕的是，您正在沿着包含标头的间接标头的悲惨道路驾驶着尖叫着乘客的公共汽车。请记住，CPP预处理器仅是智能文本替换系统。即当您看到

source.cpp 

#include "something.h"

void foo() { }

.h看起来像这样：

something.h 

class XYZ {};

经过预处理的最终翻译单元如下：

class XYZ {};

void foo() { }

如果相反，您的代码看起来像这样（不要问）：

source.cpp 

void foo() { }

#include "something.h"

结果将是：

void foo() { }

class XYZ {};

每个标头都应包含所有标头，包括标准标头和自定义标头（您的），要成功编译包含标头，则需要 ，该标头包含在带有没有其他内含物。

示例：

Pitri.h 

#pragma once

class Pitri
{
public:
    Pitri();
    ~Pitri();
    int length;
    node *head; <=== here

    void add(dood data); <=== here
    void remove(node* t); <=== here
    void printP();
    void printS();
    void printBL();
    void populate(int);
    void cycle(int);
    int getBB();
    int getBL();
    int getLL();

private:
    int ttl,mort,birth;
};

上面的<=== here标记显示了此标头所依赖的内容。因此，在遇到这些标头之前，必须 或将其预先声明。

修复了Pitri.h 

#pragma once

#include "node.h"
#include "dood.h"


class Pitri
{
public:
    Pitri();
    ~Pitri();
    int length;
    node *head;

    void add(dood data);
    void remove(node* t);
    void printP();
    void printS();
    void printBL();
    void populate(int);
    void cycle(int);
    int getBB();
    int getBL();
    int getLL();

private:
    int ttl,mort,birth;

};

现在，有人可以这样做：

#include "Pitri.h"

// use anything to do with class Pitri here.

代码将编译。

继续此操作，我们来到node.h，然后再次遇到相同的问题：

node.h 

#pragma once
class node
{
public:
    node();
    ~node();
    node* next;
    dood data; <=== here
};

因此...

修复了node.h 

#pragma once

#include "dood.h"

class node
{
public:
    node();
    ~node();
    node* next;
    dood data;
};

最后，主题包括以翻译单位（您的cpp文件）正确的标题。一般做法是：

  1. 仅在cpp文件中包含用于编译代码所需的标头。
  2. 请勿建立隐式包含依赖项
  3. 建议：在标准标头之前先添加用户标头 first 。这有助于（2）的理智。

第二个和第三个选项应该进行一些解释，并给出一个简单的示例。假设标题"foo.h"中有一些内容，该内容需要<map>中的内容。不注意，您可以这样做：

foo.h 

std::map<int,int> mapfoo();

foo.cpp 

#include <map>
#include "foo.h"

这是我的朋友，是隐式标头依赖项。坏。包含cpp文件是唯一允许foo.h编译到此转换单元中时编译的文件，并且仅是因为首先包含了<map>。当有人在没有foo.h的情况下加入<map>时，这种问题会变得很棘手，所以要做到这一点。如果您这样做：

foo.cpp 

#include "foo.h"
#include <map> // used somewhere down there.

现在在编译foo.h并包含在cpp中时会崩溃，因为编译器不知道map是什么。现在，“修复”更加清晰。不要像这样建立包含顺序的依存关系。相反：

foo.h 

#include <map>

std::map<int,int> mapfoo();

foo.cpp 

#include "foo.h"
#include <map> // optional , leave out unless maps are use regardless of `foo.h` stuff

最终，您对标头的管理方式将有所不同，但是这种机制是可靠的，并且具有适当的include-guards（或者如果您的工具链支持，则为pragma），将在确保代码依赖关系最小的情况下引入最小的构建性能损失。正确维护。

希望有帮助。

相关问题
最新问题