C++ C++；程序编译器错误：没有匹配的函数

我用一个链表来实现一个协调程序。尝试使用g++编译程序时，我遇到以下编译器错误：

concordancetest.cpp:在函数“void build_list（std:：ifstream&，char*）”中：
concordancetest.cpp:65:错误：调用“Concordance:：insert（char*&，int&）”时没有匹配的函数
注释：候选项是：void concordance:：insert（char（&）[9]，int&）

以下是我编写的代码：

头文件：

#ifndef CONCORDANCE_H
#define CONCORDANCE_H

#include <iostream>
#include <cstdlib>

const int MAX = 8;

class Concordance
{
    public:
        //typedef
        typedef char Word[MAX+1];

        //constructor
        Concordance();

        //destructor
        ~Concordance();

        //modification member functions
        void insert(Word& word, int& n);
        void remove(Word& word);
        int get_count(Word& word);

        //constant member functions
        int length() const;

        //friend member functions
        friend std::ostream& operator << (std::ostream& out_s, Concordance& c); 

    private:
        struct Node
        {
            Word wd;
            int count;
            Node *next;
        };
        Node *first;    

       Node* get_node(Word& word, int& count, Node* link);   
};

#endif

#如果不一致#
#定义一致性
#包括
#包括
常数int MAX=8；
阶级和谐
{
公众：
//类型定义
typedef字符字[MAX+1]；
//建造师
一致性（）；
//析构函数
~Concordance（）；
//修改成员函数
空白插入（文字和文字，内部和外部）；
无效删除（单词和单词）；
int get_计数（字和字）；
//常数成员函数
int length（）常量；
//友元成员函数
friend std：：ostream和操作员next；
删除临时文件；
}
}
void Concordance:：insert（单词和单词、int和n）
{
节点*prev；
if（first==NULL | | strcmp（first->wd，word）>0）
第一个=获取节点（字，n，第一个）；
其他的
{
prev=第一；
while（prev->next！=NULL&&strcmp（prev->next->wd，word）>0）
上一个=上一个->下一个；
prev->next=get_节点（word，n，prev->next）；
}
}
无效一致性：：删除（Word和Word）
{
节点*prev，*temp；
prev=温度；
如果（上一个->单词==单词）
{
第一个=第一个->下一个；
删除上一页；
}
其他的
{
while（strcmp（prev->next->wd，word）>0）
上一个=上一个->下一个；
温度=上一个->下一个；
上一个->下一个=临时->下一个；
删除临时文件；
}
}
int Concordance:：get_计数（单词和单词）
{
while（strcmp（first->wd，word）！=0）
第一个=第一个->下一个；
返回第一->计数；
}
int Concordance:：length（）常量
{
节点*光标；
内伦；
len=0；
对于（游标=第一个；游标！=NULL；游标=游标->下一个）
len++；
回程透镜；
}
一致性：：节点*一致性：：获取节点（单词和单词、整数和计数、节点*链接）
{
节点*温度；
temp=新节点；
strcpy（temp->wd，word）；
临时->下一步=链接；
临时->计数=计数+1；
返回温度；
}
ostream&operator字符数组[]

的类型是

char*

，因此当它查找匹配函数时，找不到任何函数。您可以使用

typedef char*Word

并在需要它的函数中强制执行最大长度。

字符数组[]的类型是

char*

，因此当它查找匹配的函数时，找不到匹配的函数。您可以使用

typedef char*Word并在需要它的函数中强制执行最大长度。
您的代码试图在需要数组引用的位置传递指针；您不能这样做。对于adviceyour代码的引用，您的代码试图在需要对数组进行引用的位置传递指针；您不能这样做。请参考advicechange
void insert（Word&Word，int&n）到<代码>无效插入（单词、int&n）通过引用传递数组没有意义更改
void insert（Word&Word，int&n）到<代码>无效插入（单词、int&n）通过引用传递数组没有意义
//class definition
#include "concordance.h"
#include <iostream>
#include <cstring>
#include <iomanip>
using namespace std;

Concordance::Concordance()
{
    first = NULL;
}

Concordance::~Concordance()
{
    Node *temp;
    while(first != NULL)
    {
        temp = first;
        first = first -> next;
        delete temp;
    }
}

void Concordance::insert(Word& word, int& n)
{
    Node *prev;

    if(first == NULL || strcmp(first -> wd, word) > 0)
        first = get_node(word, n, first);
    else
    {
        prev = first;

        while(prev -> next != NULL && strcmp(prev -> next -> wd, word) > 0)
            prev = prev -> next;
        prev -> next = get_node(word, n, prev -> next);
    }
}

void Concordance::remove(Word& word)
{
    Node *prev, *temp;
    prev = temp;
    if(prev -> wd == word)
    {
        first = first -> next;
        delete prev;
    }
    else
    {
        while(strcmp(prev -> next -> wd, word) > 0)
            prev = prev -> next;
        temp = prev -> next;
        prev -> next = temp -> next;
        delete temp;
    }
 }

int Concordance::get_count(Word& word)
{
    while(strcmp(first -> wd, word) != 0)
        first = first -> next;

    return first -> count;
}

int Concordance::length() const
{
    Node *cursor;
    int len;

    len = 0;
    for(cursor = first; cursor != NULL; cursor = cursor -> next )
      len++;
    return len;
}

Concordance::Node* Concordance::get_node (Word& word, int& count, Node* link)
{
    Node *temp;

    temp = new Node;
    strcpy(temp-> wd, word);
    temp-> next = link;
    temp -> count = count+1;
    return temp;
}

ostream& operator << (ostream& out_s, Concordance& c)
{
    Concordance::Node *cursor;

    out_s << "Word" << setw(10) << " " << "Count" << endl;
    out_s << "--------------------" << endl;

    for(cursor = c.first; cursor != NULL && cursor->next != NULL; cursor = cursor-> next )
      out_s << cursor-> wd << setw(10) << " " << cursor -> count << endl;

    if(cursor != NULL)
      out_s << cursor-> wd << setw(10) << " " << cursor -> count << endl;
    out_s << "--------------------" << endl;

    return out_s;
}

#include <iostream>
#include <iomanip>
#include <fstream>
#include <cstring>
#include "concordance.h"
using namespace std;

void read_word(ifstream& in_file, char array[]);
void build_list(ifstream& in_file, char array[]);

int main()
{
    char file_name[100];
    ifstream in_file;
    char array[MAX+1];

    cout << "Enter a file name: ";
    cin >> file_name;

    in_file.open(file_name);

    build_list(in_file, array);

    in_file.close();

    return EXIT_SUCCESS;
}   

void read_word(ifstream& in_file, char array[])
{
    char ch;
    int i = 0;

    in_file.get(ch);

    while(isalpha(ch) && !isspace(ch))
    { 
        if(i > MAX-1)
        {
            while(!isspace(ch))
            in_file.get(ch);
            break;
        }

        ch = tolower(ch);
        array[i] = ch;
        i++;
        in_file.get(ch);
    }

    for(int j = 0; j < i; j++)
        cout << array[j];
    cout << endl;

}

void build_list(ifstream& in_file, char array[])
{
    Concordance c;
    int count = 0;

    while(!in_file.eof())
    {
        read_word(in_file, array);
        c.insert(array, count);
    }

    cout << c;
}