2

我正在尝试将我编写的程序分解为两个源文件，但是在链接它们时遇到了问题，并且错误消息对我来说没有任何意义。

我将提供包含相关信息的文件的缩短版本：

//grandiose.cpp:

#include "thingy.h"

int main() {}

//thingy.h:
#include<string>
int add (int x, int y);
char * parse_input_fragment(const string & ,const string & , size_t &, size_t &);

//thingy.cpp:
#include "thingy.h"

int add (int x, int y)
{
    return x+y;
}

char * parse_input_fragment(const string & objective,const string & input, size_t & first_finder, size_t & second_finder) {
    char * string_to_int_buffer = new char[64];
    first_finder = input.find(objective, first_finder);
    first_finder = (input.find('=', first_finder))+1;
    second_finder = input.find(';', first_finder);
    int y = 0;
    for(unsigned int x = first_finder; x < second_finder; x++) {
        if (  (input[x] != ' ') && (input[x] != '\n') ) {
            string_to_int_buffer[y] = input[x];
            y++;
        }
    }
    string_to_int_buffer[y] = '\0';
    first_finder = second_finder;
    return string_to_int_buffer;
}

如果我将 parse_input_fragment 函数放在 grandiose.cpp 中，它编译得很好，但是当我按照描述拆分它时会收到错误消息。我包括了“添加”功能用于测试目的，并且编译得很好。

我收到的错误消息是关于thingy.h 中的原型：错误C4430：缺少类型说明符-假定为int。注意：C++ 不支持默认整数

它被清楚地标记为字​​符指针返回类型，并且在没有从 grandiose.cpp 中拆分出来时可以工作，所以我对这里的问题感到很困惑。

编辑：

好的，在移动 using namespace std 之后；到适当的位置并按照建议包含标头保护，这些错误消息消失了，但我得到了新的消息，我对此感到更加困惑。我将包括完整的文件和错误消息。

错误消息：province.obj : error LNK2005: "public: __thiscall Province::province(void)" (??0province@@QAE@XZ) 已在 grandiose.obj 中定义

Province.obj : 错误 LNK2005: "public: __thiscall Province::province(class std::basic_string,class std::allocator >,int * const)" (??0province@@QAE@V?$basic_string@DU?$ char_traits@D@std@@V?$allocator@D@2@@std@@QAH@Z) 已经在 grandiose.obj 中定义

    // grandiose.cpp : Defines the entry point for the console application.
    //

    #include "stdafx.h"
    #include <vector>
    #include <ctime>
    #include <iostream>
    #include <fstream>
    #include <string>
    #include "market.h"

    int _tmain(int argc, _TCHAR* argv[])
    {
        market England;
        ifstream reader;
        reader.open ("provinces.txt", ios::in);
        if (reader.is_open()) {  //check if txt file successfully opened
            cout << "\n\nprovinces.txt was successfully opened.\n\n";
        }
        else {
            cout << "\n\nfile was not successfully opened.\n\n";
            return (1);
        }
        string reader_buffer;
        while ( reader.good() ) { // while not end of file
            getline (reader, reader_buffer, '}'); // get one province's worth of data from txt file
            if (!reader_buffer.empty()) {
                parse_provinces (reader_buffer); // send data to be parsed
            }
        }
        add(1,2);
        return 0;
    }


    //market.h

    #include <iostream>
    #include <list>
    #include "province.h"
    using namespace std;

    class market
    {
        public:
        list<province> provinces;
    };

    //province.h

    #ifndef PROVINCE_H
    #define PROVINCE_H
    #include <iostream>
    #include <string>

    using namespace std;

    int add (int x, int y);
    char * parse_input_fragment(const string & ,const string & , size_t &, size_t &);

    class province
    {
    public:
        province::province();
        province::province(string, int[]);
        unsigned int * rural_poor;
        unsigned int * urban_poor;
        unsigned int * max_mine_jobs;
        unsigned int * max_farm_jobs;
        unsigned int * employed_mine;
        unsigned int * employed_farm;
        unsigned int * employed_factory;
        string name;
    };
    province::province () {
        rural_poor = new unsigned int(0);
        urban_poor = new unsigned int(0);
        max_mine_jobs = new unsigned int(0);
        max_farm_jobs = new unsigned int(0);
        employed_mine = new unsigned int(0);
        employed_farm = new unsigned int(0);
        employed_factory = new unsigned int(0);
        name = "";
    }
    province::province (string name, int numbers[]) {
        province::name = name;
        cout << "This province is named " << province::name << endl;
        rural_poor = new unsigned int(numbers[0]);
        cout << "Rural poor = " << *rural_poor << endl;
        urban_poor = new unsigned int(numbers[1]);
        cout << "Urban poor = " << *urban_poor << endl;
        max_mine_jobs = new unsigned int(numbers[2]);
        cout << "Max mine jobs = " << *max_mine_jobs << endl;
        max_farm_jobs = new unsigned int(numbers[3]);
        cout << "Max farm jobs = " << *max_farm_jobs << endl;
    }

    province * parse_provinces(string);

    #endif

    //province.cpp

    #include "stdafx.h"
    #include "province.h"

    int add (int x, int y)
    {
        return x+y;
    }

    char * parse_input_fragment(const string & objective,const string & input, size_t & first_finder, size_t & second_finder) {
        char * string_to_int_buffer = new char[64];
        first_finder = input.find(objective, first_finder);
        first_finder = (input.find('=', first_finder))+1;
        second_finder = input.find(';', first_finder);
        int y = 0;
        for(unsigned int x = first_finder; x < second_finder; x++) {
            if (  (input[x] != ' ') && (input[x] != '\n') ) {
                string_to_int_buffer[y] = input[x];
                y++;
            }
        }
        string_to_int_buffer[y] = '\0';
        first_finder = second_finder;
        return string_to_int_buffer;
    }

    province * parse_provinces(string input) {
        size_t first_finder;
        size_t second_finder;
        char * string_to_int_buffer;
        int population_info[4];


        // find the name
        first_finder = input.find('=');
        string name;
        for(unsigned int x = 0; x < first_finder; x++) {
            if ((input[x] != ' ') && (input[x] != '\n')) {
                name.push_back(input[x]);
            }
        }

        // find the rural poor
        string_to_int_buffer = parse_input_fragment("rural_poor", input, first_finder, second_finder);
        population_info[0] = atoi(string_to_int_buffer);

        // find the urban poor
        string_to_int_buffer = parse_input_fragment("urban_poor", input, first_finder, second_finder);
        population_info[1] = atoi(string_to_int_buffer);

        // find max mine jobs
        string_to_int_buffer = parse_input_fragment("max_mine_jobs", input, first_finder, second_finder);
        population_info[2] = atoi(string_to_int_buffer);

        // find max farm jobs
        string_to_int_buffer = parse_input_fragment("max_farm_jobs", input, first_finder, second_finder);
        population_info[3] = atoi(string_to_int_buffer);

        delete[] string_to_int_buffer;
        string_to_int_buffer = NULL;
        province * current_province = new province(name, population_info);
        return current_province;
    }
4

3 回答 3

2

即使您包含<string>，您也需要使用std命名空间来访问string类型：

#include<string>
using namespace std;

该类型string位于 std 命名空间中，因此仅键入string不会命名已知类型。

或者，您可以在标头中替换所有出现的stringwithstd::string并使用using.cpp 中的语句（实际上这是所需的做事方式，因为它避免了所有std函数和类型的全局命名空间。

Jason 的回答也是一个很好的建议：使用包含保护来保护您的标头，因此如果您两次（例如间接）包含相同的标头，您将不会因多个定义而出现编译器错误（C++ 有一个单一定义规则：所有类只能定义一次）。在您的特定情况下，这不是问题，但是养成避免后面问题的习惯是一件好事

于 2012-04-28T17:18:17.417 回答
0

正如您开始包含多个文件时的风格问题一样，您应该在头文件的顶部放置一个预处理器保护，以防止它们被包含两次并导致解析错误。例如，您应该在所有标题中放置以下内容：

//first thing at the top of the header
#ifndef THINGY_H
#define THINGY_H

//...the actual header code

//the very last line of the header
#endif //THINGY_H

这样，如果在代码模块的编译过程中，你最终得到了一个包含两次的头文件，那么预处理器将已经定义了 header-guard 标记，因此，不会包含来自第二个头文件副本的代码.

于 2012-04-28T17:15:11.697 回答
0

将您的实现移动到 cpp 文件或在标头中内联实现的构造函数/方法以解决链接器错误。

于 2012-04-28T17:52:39.133 回答