Блог

Я получаю таинственную ошибку в моем проекте, которая гласит:

ожидаемый конструктор, деструктор или преобразование типа

Это не позволяет мне использовать мой перегруженный operator<< . Это ранее работало, прежде чем я превратил свой класс ( myVector ) в template

 //MyVector class
//An implementation of a vector of integers.
template <class T>
class MyVector{
public:
    //Purpose: Initialize an object of type MyVector
    //Parameters: none.
    //Returns: nothing.
    MyVector();

    //------------------------------------------------
    //Purpose: Initialize an object of type MyVector
    //Parameters: an integer.
    //Returns: nothing.
    //------------------------------------------------
    MyVector(int);

    //Purpose: Destroys objects of type MyVector
    //Parameters: none.
    //Returns: nothing
    //------------------------------------------------
    ~MyVector();

    //Purpose: Returns the current size of the MyVector.
    //Parameters: none.
    //Returns: the size.
    int size() const;

    //------------------------------------------------
    //Purpose: Returns the capacity of the MyVector.
    //Parameters: none.
    //Returns: int.
    int capacity() const;

    //------------------------------------------------
    //Purpose: Removes the entries of MyVector.
    //Parameters: none.
    //Returns: nothing.
    void clear();

    //------------------------------------------------
    //Purpose: Appends a given integer to the vector.
    //Parameters: an integer.
    //Returns: nothing.
    void push_back(T);

    //------------------------------------------------
    //Purpose: Shows what's at a given position.
    //Parameters: an integer index.
    //Returns: an integer.
    T at(int) const;

    MyVector(const MyVectoramp; b);
    const MyVectoramp; operator=(const MyVectoramp;);

    //------------------------------------------------

private:
    int _size;
    int _capacity;
    int* head;

    //Purpose: Increases the capacity of a MyVector when it's 
    // capacity is equal to it's size. Called by push_back(int)
    //Parameters/Returns: nothing.
    void increase();

    //Purpose: Copies the given vector reference. 
    //Param: MyVector reference.
    //Returns: nothing.
    void copy(const MyVectoramp;);

    //Purpose: Frees MyVector up for an assignment.
    void free();
};

template <class T>
ostreamamp; operator<<(ostreamamp;, const MyVector<T>);
//This line is giving me the error.

#endif
  

У меня есть код для оператора в отдельном файле:

 template <class T>
ostreamamp; operator<<(ostreamamp; os, const MyVector<T> V){
    int N = V.size();
    os << endl;
    for(int i = 0; i<N; i  ){
        os << V.at(i)<<endl;
    }
    return os;
}
  

Я рассмотрел другие вопросы, но, похоже, ни один из них не соответствует моему. Помощь была бы высоко оценена. Спасибо!

Вероятно, вам нужно квалифицировать ostream с std как:

std::ostreamamp; operator<<(std::ostreamamp;, const MyVector<T>);

И вы почти наверняка должны передавать свой вектор по постоянной ссылке, а не по постоянному значению.

Вы не можете объявить шаблон в файле, а затем определить его в другом файле. Вы можете только определить это.

Надеюсь, это помогло вам.

Вы должны заставить функцию operator<< принимать постоянную ссылку на MyVector , а не просто константу, поскольку то, что вы делаете, — это создание копии вектора для передачи в функцию.

 template <class T> std::ostreamamp; operator<<(ostreamamp; o, const MyVector<T>amp; V)
  

Ожидаемый конструктор, деструктор или преобразование типа предполагает, что он не распознает ostream как тип (т. Е. Он не был объявлен в этой области видимости). Для решения проблемы недостаточно только префикса std::; необходимо также включить зависимый файл.

 #include <ostream> 
  

Нет необходимости объявлять это:

 template <class T>
ostreamamp; operator<<(ostreamamp;, const MyVector<T>);
  

Вы можете следовать этому

 #include <iostream>
using namespace std;
template <class T>
class A
{
public:
A();
int _size;
};
template <class T>
ostreamamp; operator<<(ostreamamp;, const A<T> p)
{
cout<<"in ostream"<<endl;
}
template <class T>
A<T>::A()
{
_size = 90;
cout<<_size<<endl;
}
int main()
{
A<int> ob;
cout<<ob;
return 0;
}