c++ - C ++：リンカーエラー：別のファイルで定義された1つの特定のクラスメンバーのみへの未定義の参照

Question

複数のファイルをコンパイルしてリンクしようとすると、悪名高い「未定義の参照」エラーが発生します。お役に立てれば幸いです。

正確なエラーメッセージ：

g ++ -o main list.cpp main.cpp /tmp/ccv6M2I6.o：関数main': main.cpp:(.text+0x219): undefined reference toList :: print（）const '

main.cpp：

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


void printStats(IntList& l) {
    cout << endl << "____________________" << endl;
    cout << "Length: " << l.getCount() << endl;
    cout << "Min: " << l.min() << endl;
    cout << "Max: " << l.max() << endl;
    cout << "Average: " << l.average();
    cout << endl << "____________________" << endl;
}

int main() {
    IntList l = IntList();

    for(int i=1; i <= 10; i++) {
        l.insert(i, l.getCount() - 1); // works fine
    }

    printStats(l); // works fine, too
    l.print(); // causes the error

    return 0;
}

面白いのは、メンバー関数insert（）もmin（）、max（）、average（）も問題を引き起こさないということです。それはただのprint（）です。

[編集]：print（）だけでなく、remove（）でもあります。

list.hpp：

#ifndef __LIST_HPP__
#define __LIST_HPP__

template <typename T>
class List {
    public:
        class OutOfBoundsException { };

        List();
        List(const List& l);
        ~List();

        List& operator=(const List& l);

        unsigned int getCount() const;
        bool isEmpty() const;
        void print() const;
        void insert(T value, unsigned int position = 0);
        void remove(unsigned int position);
        T pop(unsigned int position = 0);
        T getElement(unsigned int position) const;

    protected:
        // double linked list
        struct dllist_entry {
            T value;
            dllist_entry* next;
            dllist_entry* prev;
        };

        dllist_entry* first;
        dllist_entry* last;

        unsigned int length;

        void clear();

        dllist_entry* getElementRaw(unsigned int position) const;
};

class IntList : public List<int> {
    public:
        IntList();
        IntList(const IntList& l);
        ~IntList();

        IntList& operator=(const IntList& l);

        int max() const;
        int min() const;
        float average() const;
};


#endif

list.cpp：

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


template <typename T>
List<T>::List() {
    this->first = NULL;
    this->last = NULL;
    this->length = 0;
}

template <typename T>
List<T>::List(const List& l) {
    this->first = NULL;
    this->last = NULL;
    this->length = 0;

    for(unsigned int i=0; i < l.getCount(); i++) {
        insert(l.getElement(i));
    }
}

template <typename T>
List<T>& List<T>::operator=(const List<T>& l) {
    if(this != &l) {    
        // Liste leeren
        clear();

        for(unsigned int i=0; i < l.getCount(); i++) {
            insert(l.getElement(i));
        }
    }

    return *this;
}

template <typename T>
List<T>::~List() {
    clear();
}

template <typename T>
void List<T>::clear() {
    dllist_entry* iter = first;
    dllist_entry* next;

    while(iter != NULL) {
        next = iter->next;
        delete iter;
        iter = next;
    }

    length = 0;
}

template <typename T>
unsigned int List<T>::getCount() const {
    return this->length;
}

template <typename T>
bool List<T>::isEmpty() const {
    return this->length == 0;
}

template <typename T>
void List<T>::print() const {
    // aus Performance-Gründen nicht getElement() benutzen

    for(dllist_entry* iter = first; iter != NULL; iter = iter->next) {
        cout << iter->value << endl;
    }
}

template <typename T>
void List<T>::insert(T value, unsigned int position) {

    dllist_entry* new_one = new dllist_entry;
    new_one->value = value;

    if(getCount() > 0) {
        if(position < getCount()) {
            if(position == 0) {
                new_one->prev = NULL;
                new_one->next = first;
                first->prev = new_one;
                first = new_one;
            }
            // position > 0
            else {
                dllist_entry* elem = getElementRaw(position);
                new_one->next = elem;
                new_one->prev = elem->prev;
                elem->prev->next = new_one;
                elem->prev = new_one;
            }
        }
        else if(position == getCount()) {
                new_one->next = NULL;
            new_one->prev = last;
            last->next = new_one;
            last = new_one;
        }
        else {
            throw OutOfBoundsException();
        }
    }
    else {
        new_one->next = NULL;
        new_one->prev = NULL;
        first = new_one;
        last = new_one;
    }

    length++;
}    

template <typename T>
T List<T>::pop(unsigned int position) {
    T value = getElement(position);
    remove(position);
    return value;
}

template <typename T>
void List<T>::remove(unsigned int position) {
    dllist_entry* elem = getElementRaw(position);


    if(getCount() == 1) { // entspricht elem == first && elem == last
        first = NULL;
        last = NULL;
    }
    else if(elem == first) {
        elem->next->prev = NULL;
        first = elem->next;
    }
    else if(elem == last) {
        elem->prev->next = NULL;
        last = elem->prev;
    }
    // Element liegt zwischen Anfang und Ende
    // (Wäre das nicht so, hätte getElementRaw() bereits protestiert.)
    else {
        elem->prev->next = elem->next;
        elem->next->prev = elem->prev;
    }

    delete elem;
    length--;
}

template <typename T>
T List<T>::getElement(unsigned int position) const {
    return getElementRaw(position)->value;
}

template <typename T>
typename List<T>::dllist_entry* List<T>::getElementRaw(unsigned int position) const {
    // schließt den Fall getCount() == 0 mit ein
    if(position < getCount()) {
        dllist_entry* iter;

        // aus Performance-Gründen mit der Suche entweder von vorne oder 
        // von hinten beginnen
        if(position <= (getCount() - 1) / 2) {
            iter = first;

            for(unsigned int i=0; i < position; i++) {
                iter = iter->next;
            }
        }
        else {
            iter = last;

            for(unsigned int i = getCount() - 1 ; i > position; i--) {
                iter = iter->prev;
            }
        }

        return iter;
    }
    else {
        throw OutOfBoundsException();
    }
}





IntList::IntList() : List<int>() { }
IntList::IntList(const IntList& l) : List<int>(l) { }
IntList::~IntList() { }

IntList& IntList::operator=(const IntList& l) {
    List<int>::operator=(l);
    return *this;
}


int IntList::min() const {
    // erstes Element separat holen, damit OutOfBoundsException geworfen werden
    // kann, wenn Liste leer ist
    int min = getElement(0);

    for(unsigned int i=1; i < getCount(); i++) {
        int value = getElement(i);
        if(value < min) {
            min = value;
        }
    }

    return min;
}

int IntList::max() const {
    // erstes Element separat holen, damit OutOfBoundsException geworfen werden
    // kann, wenn Liste leer ist
    int max = getElement(0);

    for(unsigned int i=1; i < getCount(); i++) {
        int value = getElement(i);
        if(value > max) {
            max = value;
        }
    }

    return max;
}

float IntList::average() const {
    if(getCount() > 0) {
        int sum = 0;

        for(unsigned int i=0; i < getCount(); i++) {
            sum += getElement(i);
        }

        return (float) sum / getCount();
    }
    else {
        return 0;
    }
}

大量の情報源については申し訳ありませんが、抜粋を投稿しただけでは、誤って何かを省略してしまう可能性があるのではないかと心配していました。

記録のために：list.hpp / list.cppでデストラクタ〜IntList（）を明示的に宣言/定義する前に、同様のエラーメッセージ（今回はList ::〜List（））を受け取りました。IntListオブジェクトを破棄するときに、親クラスListのデストラクタが呼び出されるので、実際には宣言する必要はないと思っていましたか？また、ヘッダーファイルlist.hppでデストラクタを「〜IntList（）{}」として直接定義しても、トリックは実行されませんでした。dtor定義をlist.cppに移動するまで、エラーメッセージは消えませんでした。

ちなみに、私がまだ1つの大きなファイルに入れていたとき、すべてが素晴らしくコンパイルされました。

このバグを探し出すのに時間を割いてくれてありがとう！:)

score 4 · Accepted Answer

テンプレートの定義は、宣言が提供されているのと同じファイルにある必要があります。それらを分離することはできません。

したがって、のすべての定義をに移動するかlist.cpp、list.hppまたはでこれを実行しますlist.hpp

#ifndef __LIST_HPP__
#define __LIST_HPP__

template <typename T>
class List {

//...

};

class IntList : public List<int> {

//...

};

#include "list.cpp"  //<----------------- do this

#endif

そして、ファイル#include list.hppからその行を削除しlist.cppます。それはそれを円形にしています：

#include <iostream>
//#include "list.hpp" //remove this
using namespace std; //<----- don't do this either - see the note below!


template <typename T>
List<T>::List() {
    this->first = NULL;
    this->last = NULL;
    this->length = 0;
}
//....

ちなみに、使用済みusing namespace stdです。次のような完全修飾名を使用します。

std::vector<int> v;
std::sort(...);
//etc

score 1 · Accepted Answer

テンプレート化されたコードはヘッダーファイルに含まれている必要があります。

テンプレートはコンパイラによって生成されたコードであり、コードで使用すると「オンデマンド」で生成されます。

ヘッダーファイルにない場合、適切なコードを見つけて特定のタイプ用に生成することはできません。

これまでに行ったことはList<int>、独自の実装でメンバー関数を継承して非表示にするクラスを作成することです。

ただし、を実装していませんprint()。また、テンプレートのソースがファイルに含まれていないため、のコードをList<int>.print()生成できませんでした。

編集：

print()エラーが発生した理由を明確にするために、次のようにします。

main関数では、次の3つの関数を使用していgetCount() insert()ます。print()

それでは、List<int>：の実装を見てみましょう。

コピーコンストラクターで...を呼び出しList(const List& l)ます。

IntList::IntList(const IntList& l) : List<int>(l) { }

そのコンストラクターは、、insert()およびgetCount()を呼び出しgetElement()ます。

    for(unsigned int i=0; i < l.getCount(); i++) {
    insert(l.getElement(i));
}

したがって、これらの関数はすべて、クラスのIntListコンパイル時に作成されます。
の実装はIntList、テンプレートの実装を「参照」して、それらの関数が作成されるようにします。

一方、は、テンプレートの実装を「認識」しない関数でprint<int>()初めて呼び出されます。main

c++ - C ++：リンカーエラー：別のファイルで定義された1つの特定のクラスメンバーのみへの未定義の参照

2 に答える 2

Related

Reference