no matching function for call to error when compiling

Question

no matching function for call to error when compiling

Navigation

#1 by (4 votes)

0

I have a question with a program that I did, it is a class to do vector operations, I create two vectors with the constructor of the class, one is passed as a parameter to the function suma() , to add two vectors, which it happens that I get an error when compiling, which says that there are undefined references, which I do not understand:

This is the class with the headers:

#pragma once
#include<iostream>
#include<vector>
#include <cassert>
using namespace std;

template <class T>

class vector_t{
private:
  T* data_;
  int sz_;

public:
  vector_t(void);
  vector_t(int sz);
  ~vector_t(void);
  void resize(int sz);
  int get_sz(void) const;
  T get_v(int pos) const;
  T& get_set_v(int pos);
  void set_v(T data);

  vector_t<double> suma(vector_t<T> b, double suma);
  vector_t<int> suma(vector_t<T> b, int suma);

  ostream& write(ostream& os) const;
private:
  void crea_vector(void);
  void destruye_vector(void);

};

reference to vector_t<int>::vector_t(int)' sin definir main_vector.cpp:10: referencia a vector_t :: vector_t () 'undefined main_vector.cpp: 11: reference to vector_t<int>::vector_t(int)' sin definir main_vector.cpp:13: referencia a vector_t :: sum (vector_t, int) 'undefined

referring to main :

#include<iostream>
#include<vector>
#include<cassert>
#include "vector.hpp"
using namespace std;
// -std=c++11
int main (void){
  int suma=0;
  vector_t<int> a(8);
  vector_t<int> b;
  vector_t<int> a1(8);

  b.suma(a1,suma);
}

Maybe the problem is with the way I invoke the constructors, but I do not know.

This is the definition of the two constructors:

vector:: vector_t(void){
    data_=NULL;
        sz_=0;
  }
  vector:: vector_t (int sz){
    data_=NULL;
    sz_=sz;
    int num;

    for(int i=1; i<=sz_;i++){
      cout<<"Introduzca el "<<i<<"número del primer vector "<<endl;
      cin>>num;
      data_[i]=num;
    }
  }

Thanks in advance

c++ compilador

asked by AER 10.02.2018 в 23:11

source

1 answer

Problem in XML document declaration [closed] add in bd a date 2 days after today without counting saturday and sunday in mysql php

score 4 · Accepted Answer

The templates have the particularity that both the declaration and the implementation must be always in a header file.

Why?

Basically because the compiler, when encountering a template, does absolutely nothing ... it does not generate any code. It is expected to find uses of said template to generate the specializations that are required.

But why?

We will agree to say that a template could soon be specialized with a int than with a class that in turn contains 20 vectors and 200 variables, right? And it is easy to see that the size that occupies a int is going to be quite lower than the size of the class. Consequently, the code generated for each specialization can be completely different.

If, taking into account the above, we force the compiler to generate specializations when encountering the declaration of the template ... What specializations should you create? All? Even the type you still do not know about? It's something unreal and that would only serve to create insultingly large executables.

What happens then is that the compiler writes down the templates that it finds but does nothing with them until they are not used ... at that moment it creates only and exclusively the specializations that are used in the code .

Compilation unit

We are going to make a small paragraph to explain a detail that is important in the face of what comes next.

If you have ever tried to compile manually, has not it caught your attention that the compiler can pass all the implementation files at once and that, however, it is necessary to use #include ? Put another way ... if the compiler has already passed all the cpp ... What's the point of the headers?

The process of generating an executable in C ++ consists of 2 steps:

Compilation
Assembled

In the compilation process the compiler will process each cpp individually. For this, it loads the cpp and launches a utility called preprocessor. This process is responsible for interpreting the #include , #define and others. When a #include is found, it replaces it with the contents of the file it refers to .... if this file has other #include nested the process will be repeated again and again until there is not a single #include for processing. That is, a cpp consists of the file itself and of all the headers to which it refers either directly or indirectly ... and that is all the information that the compiler has to carry out its work. This set of files is called the compilation unit.

After the compilation process, the linker is launched. His job is to take the object code files that were generated during the compilation to merge them into a binary.

Going back to templates

Well, to understand the theme of the templates you have to take into account these three points:

The compiler does nothing with the templates until it finds uses of them
To compile a template you need to know its implementation
The compiler only has the information contained in the compilation unit (code referenced by #include )

With these requirements on the table it is easy to understand why the code of the templates should travel together. If the template is separated, the compiler will not have the template implementation at its disposal and will not know how to generate the corresponding code.

Errors in the code

If, for readability, convenience, whatever the reason, you decide to put on the one hand the declaration of the template and, on the other, its implementation (always in the same file), you have to keep in mind that you must indicate that the functions belong to a template:

template<class T>
vector_t<T>::vector_t()
{
  data_=NULL;
  sz_=0;
}

And why should you do this?

They are the rules of the language. It is also a way to differentiate the original template of a specialization:

template<class T>
class vector_t
{
// ...
};

// Especializacion explicita para el tipo int    
template<>
class vector_t<int>
{
  // ...
};

// Plantilla original
template<class T>
vector_t<T>::vector_t()
{
  data_=NULL;
  sz_=0;
}

// Codigo de la especializacion a int
template<>
vector_t<int>::vector_t()
{
  // ...
}