Ir para conteúdo

POWERED BY:

Mateus GP

Linker não encontra referências

Por , em C/C++

Recommended Posts

Mateus GP    13

Mateus GP
Postado

Boa noite.

 

Estou tendo problemas para compilar um código, não tenho ideia do que está acontecendo.

 

Spoiler
[main] Compilando a pasta: Math
[build] Iniciando o build
[proc] Executando o comando: /usr/bin/cmake --build /home/mateusgp/vscProjects/Math/build --config Debug --target all -- -j 6
[build] Scanning dependencies of target vector
[build] [ 66%] Building CXX object CMakeFiles/vector.dir/main.cpp.o
[build] [ 66%] Building CXX object CMakeFiles/vector.dir/vector2.cpp.o
[build] [100%] Linking CXX executable vector
[build] /usr/bin/ld: CMakeFiles/vector.dir/main.cpp.o: na função "main":
[build] /home/mateusgp/vscProjects/Math/main.cpp:9: referência não definida para "Vector2<float>::dot(Vector2<float> const&) const"
[build] collect2: error: ld returned 1 exit status
[build] gmake[2]: *** [CMakeFiles/vector.dir/build.make:118: vector] Erro 1
[build] gmake[1]: *** [CMakeFiles/Makefile2:339: CMakeFiles/vector.dir/all] Erro 2
[build] gmake: *** [Makefile:136: all] Erro 2
[build] Build concluído com o código de saída 2

 

main.cpp 

#include <iostream>
#include "vector2.hpp"

int main(int, char **)
{
    Vector2f test;

    //test = (const float)0.0f;
    test.dot(test);

    return 0;
}

vector2.hpp 

#ifndef vector2_header
#define vector2_header
#include <cmath>

template <typename number_t>
class Vector2;

template <typename number_t>
Vector2<number_t> operator+(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator+(const Vector2<number_t> &lhs, const number_t rhs);

template <typename number_t>
Vector2<number_t> operator+(const number_t lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator-(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator-(const Vector2<number_t> &lhs, const number_t rhs);

template <typename number_t>
Vector2<number_t> operator-(const number_t lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator*(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator*(const Vector2<number_t> &lhs, const number_t rhs);

template <typename number_t>
Vector2<number_t> operator*(const number_t lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator/(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs);

template <typename number_t>
Vector2<number_t> operator/(const Vector2<number_t> &lhs, const number_t rhs);

template <typename number_t>
Vector2<number_t> operator/(const number_t lhs, const Vector2<number_t> &rhs);

template <typename number_t>
class Vector2
{
public:
    number_t x;
    number_t y;

    Vector2() : x(0.), y(0.) {}
    Vector2(const number_t x_, const number_t y_) : x(x_), y(y_) {}
    Vector2(const Vector2 &v2d) : x(v2d.x), y(v2d.y) {}

     friend Vector2 operator+<number_t>(const Vector2 &lhs, const Vector2 &rhs);
     friend Vector2 operator+<number_t>(const Vector2 &lhs, const number_t rhs);
     friend Vector2 operator+<number_t>(const number_t lhs, const Vector2 &rhs);
     friend Vector2 operator-<number_t>(const Vector2 &lhs, const Vector2 &rhs);
     friend Vector2 operator-<number_t>(const Vector2 &lhs, const number_t rhs);
     friend Vector2 operator-<number_t>(const number_t lhs, const Vector2 &rhs);
     friend Vector2 operator*<number_t>(const Vector2 &lhs, const Vector2 &rhs);
     friend Vector2 operator*<number_t>(const Vector2 &lhs, const number_t rhs);
     friend Vector2 operator*<number_t>(const number_t lhs, const Vector2 &rhs);
     friend Vector2 operator/<number_t>(const Vector2 &lhs, const Vector2 &rhs);
     friend Vector2 operator/<number_t>(const Vector2 &lhs, const number_t rhs);
     friend Vector2 operator/<number_t>(const number_t lhs, const Vector2 &rhs);

    Vector2 &operator=(const Vector2 &rhs);
    Vector2 &operator=(const number_t &rhs);

    Vector2 &operator+=(const Vector2 &rhs);
    Vector2 &operator+=(const number_t rhs);

    Vector2 &operator-=(const Vector2 &rhs);
    Vector2 &operator-=(const number_t rhs);

    Vector2 &operator*=(const Vector2 &rhs);
    Vector2 &operator*=(const number_t rhs);

    Vector2 &operator/=(const Vector2 &rhs);
    Vector2 &operator/=(const number_t rhs);

    number_t lenghtSq() const;
    number_t lenght() const;

    number_t dot(const Vector2 &rhs) const;

    number_t cross(const Vector2 &rhs) const;

    Vector2 &rotate(const number_t rad);
    Vector2 rotated(const number_t rad) const;

    Vector2 &normalize();
    Vector2 normalized() const;

    number_t distanceSq(const Vector2 &rhs) const;
    number_t distance(const Vector2 &rhs) const;

    number_t angle(const Vector2 &rhs) const;

    Vector2 absv() const;
};

typedef Vector2<float> Vector2f;
#endif // !vector2_header

vector2.cpp 

#include "vector2.hpp"

template <typename number_t>
Vector2<number_t> operator+(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs.x + rhs.x, lhs.y + rhs.y);
}

template <typename number_t>
Vector2<number_t> operator+(const Vector2<number_t> &lhs, const number_t rhs)
{
    return Vector2<number_t>(lhs.x + rhs, lhs.y + rhs);
}

template <typename number_t>
Vector2<number_t> operator+(const number_t lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs + rhs.x, lhs + rhs.y);
}

template <typename number_t>
Vector2<number_t> operator-(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs.x - rhs.x, lhs.y - rhs.y);
}

template <typename number_t>
Vector2<number_t> operator-(const Vector2<number_t> &lhs, const number_t rhs)
{
    return Vector2<number_t>(lhs.x - rhs, lhs.y - rhs);
}

template <typename number_t>
Vector2<number_t> operator-(const number_t lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs - rhs.x, lhs - rhs.y);
}

template <typename number_t>
Vector2<number_t> operator*(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs.x * rhs.x, lhs.y * rhs.y);
}

template <typename number_t>
Vector2<number_t> operator*(const Vector2<number_t> &lhs, const number_t rhs)
{
    return Vector2<number_t>(lhs.x * rhs, lhs.y * rhs);
}

template <typename number_t>
Vector2<number_t> operator*(const number_t lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs * rhs.x, lhs * rhs.y);
}

template <typename number_t>
Vector2<number_t> operator/(const Vector2<number_t> &lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs.x / rhs.x, lhs.y / rhs.y);
}

template <typename number_t>
Vector2<number_t> operator/(const Vector2<number_t> &lhs, const number_t rhs)
{
    return Vector2<number_t>(lhs.x / rhs, lhs.y / rhs);
}

template <typename number_t>
Vector2<number_t> operator/(const number_t lhs, const Vector2<number_t> &rhs)
{
    return Vector2<number_t>(lhs / rhs.x, lhs / rhs.y);
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator=(const Vector2<number_t> &rhs)
{
    if(this != &rhs)
    {
        x = rhs.x;
        y = rhs.y;
    }
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator=(const number_t &rhs)
{
    x = rhs;
    y = rhs;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator+=(const Vector2<number_t> &rhs)
{
    x += rhs.x;
    y += rhs.y;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator+=(const number_t rhs)
{
    x += rhs;
    y += rhs;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator-=(const Vector2<number_t> &rhs)
{
    x -= rhs.x;
    y -= rhs.y;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator-=(const number_t rhs)
{
    x -= rhs;
    y -= rhs;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator*=(const Vector2<number_t> &rhs)
{
    x *= rhs.x;
    y *= rhs.y;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator*=(const number_t rhs)
{
    x *= rhs;
    y *= rhs;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator/=(const Vector2<number_t> &rhs)
{
    x /= rhs.x;
    y /= rhs.y;
    return *this;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::operator/=(const number_t rhs)
{
    x /= rhs;
    y /= rhs;
    return *this;
}

template <typename number_t>
number_t Vector2<number_t>::lenghtSq() const
{
    return x * x + y * y;
}

template <typename number_t>
number_t Vector2<number_t>::lenght() const
{
    return sqrt(x * x + y * y);
}

template <typename number_t>
number_t Vector2<number_t>::dot(const Vector2<number_t> &rhs) const
{
    return x * rhs.x + y * rhs.y;
}

template <typename number_t>
number_t Vector2<number_t>::cross(const Vector2<number_t> &rhs) const
{
    return x * rhs.x - y * rhs.y;
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::rotate(const number_t rad)
{
    const number_t tx(x), dc(cos(rad)), ds(sin(rad));

    x = x * dc - y * ds;
    y = tx * ds + y * dc;

    return *this;
}

template <typename number_t>
Vector2<number_t> Vector2<number_t>::rotated(const number_t rad) const
{
    Vector2<number_t> nw(*this);
    return nw.rotate(rad);
}

template <typename number_t>
Vector2<number_t> &Vector2<number_t>::normalize()
{
    const number_t len(1. / lenght());
    x *= len;
    y *= len;
    return *this;
}

template <typename number_t>
Vector2<number_t> Vector2<number_t>::normalized() const
{
    Vector2<number_t> nw(*this);
    return nw.normalize();
}

template <typename number_t>
number_t Vector2<number_t>::distanceSq(const Vector2<number_t> &rhs) const
{
    const number_t dx(x - rhs.x);
    const number_t dy(y - rhs.y);
    return dx * dx + dy * dy;
}

template <typename number_t>
number_t Vector2<number_t>::distance(const Vector2<number_t> &rhs) const
{
    const number_t dx(x - rhs.x);
    const number_t dy(y - rhs.y);
    return sqrt(dx * dx + dy * dy);
}

template <typename number_t>
number_t Vector2<number_t>::angle(const Vector2<number_t> &rhs) const
{
    Vector2<number_t> nv(normalized());

    number_t ang(nv.dot(rhs.normalized()));
    if (ang > 1.0)
        ang = 1.0;
    if (ang < -1.0)
        ang = -1.0;
    return -acos(ang);
}

template <typename number_t>
Vector2<number_t> Vector2<number_t>::absv() const
{
    return Vector2<number_t>(abs(x), abs(y));
}

O problema é que aparentemente funciona se copiar o código de vector2.cpp para main.cpp.

 

Alguém tem alguma sugestão? Se houver outra fora o problema, também é bem-vinda.

 

Obs: já tentei compilar pelo terminal também.

Spoiler

mateusgp@debian:~/vscProjects/Math$ g++ -o app main.o vector2.o -lm
/usr/bin/ld: main.o: na função "main":
main.cpp:(.text+0x2a): referência não definida para "Vector2<float>::dot(Vector2<float> const&) const"
collect2: error: ld returned 1 exit status

 

CMakeLists.txt

Spoiler

cmake_minimum_required(VERSION 3.0.0)
project(vector VERSION 0.1.0)

include(CTest)
enable_testing()
include_directories(${PROJECT_SOURCE_DIR})

add_executable(vector main.cpp vector2.cpp)

set(CPACK_PROJECT_NAME ${PROJECT_NAME})
set(CPACK_PROJECT_VERSION ${PROJECT_VERSION})
include(CPack)

 

Compartilhar este post

Link para o post
Compartilhar em outros sites
Visitante
Este tópico está impedido de receber novos posts.
Ir para a lista de tópicos C/C++

  • Conteúdo Similar

    • Yuri Fernandes da Silva
      Pergunta: Operadores "and" (&&) e "or" (||)
      Por Yuri Fernandes da Silva
      Olá, sou um membro novo do fórum e estou estudando por conta a linguagem c++ pela internet..
       
      Durante meus estudos, me surgiu uma dúvida em relação ao conteúdo descrito no título desse fórum, mais especificamente com um compilador online (estudo no meu serviço, nos horários vagos)
       
      Essa foi a mensagem de erro que apareceu no compilador Online "C++ Shell":   In function 'int main()': 10:66: error: expected primary-expression before '<' token
       
      Esse foi o código que criei:
       
       
      //Exercício 
      #include <iostream>
      using namespace std;
      int main ()
      {
          int num;
          
          num=12;
          if ((num >=3 && num <=6) || (num > 9 && num < 15) || (num>15 && <20)) {
              cout <<"\n\nValor aceito\n";
          }else{
              cout <<"\n\nnao aceito\n";
          }
          return 0;
      }
       
       
      Agradeço desde já a atenção.
    • marciniak
      Ajuda! - Preenchimento de string através de função
      Por marciniak
      Salve!
      Estou tentando escrever em uma string (ponteiro alocado dinamicamente) através de uma função alimentada por um ponteiro
      Codigo de exemplo:
      #include <stdio.h> #include <stdlib.h> #include <string.h> void teste (char *str) { str = (char*)malloc(sizeof(char)*(strlen("teste"))); strcpy(str, "teste"); printf("%s", str); } int main() { char *str1 = NULL; teste(str1); printf("|%s", str1); return 0; }  
      A intenção é que a saída seja algo do tipo:
      teste|teste porém o resultado é:
      teste|(null)  
      Acredito que por estar enviando como referência o str1 ele deveria ser alterado pela função, e portanto permanecer como o mesmo valor de str (que aponta para ele), porém isso não acontece.
      Como deveria proceder para conseguir o resultado desejado?

      Agradeço!
    • patrick.menezes
      Como comparar 3 dados digitados com uma tabela de referência e retornar valor
      Por patrick.menezes
      Boa tarde pessoal !
       
      Como faço para comparar os valores entre duas tabelas e retornar um valor final ?
       
      Por exemplo: 
      Leia valor
      col1 = vazão(float) e
      col2 = turbidez (float)  e
      col3 = pH  (float) agora compare e busque o resultado na col4 
      solução = valor pre estabelecido na col4
       
      Quando
      vazão digitada pelo usuário estiver entre dois valores da tabela de referência ( X e Y )
      turbidez digitada pelo usuário estiver entre dois valores ( X e Y)
      pH digitado pelo usuário estiver entre dois valores ( X e Y)
      então o Mysql retorna um valor pre estabelecido na col4.
       
      Alguém poderia me ajudar a resolver este problema?
       
      Agradeço desde já.
       
    • willianlq
      Método não compila
      Por willianlq
      Fala pessoal, não estou conseguindo escrever esse método para que compile
      OBS: Não estou me achando só nos métodos(comecei a pouco em programação, então gostaria da ajuda de vocês).
       
      -classe parcela
       
      *Atributos privados
      dataVencimento – objeto do tipo da classe Data
      - valorOriginal – é o valor da parcela, sem qualquer acréscimo (float ou double)
      - valorFinal – é o valor original acrescido ou não de juros por atraso no pagamento (float ou double)
      - situacao – tipo char. Os valores possíveis são:
                                              N – parcela ainda não venceu, nem foi paga;
                                              Q – parcela já foi quitada (paga);
                                              A - parcela ainda não foi paga e está em atraso.
      *Construtor: um apenas, com três parâmetros: tipo Cliente, tipo Data (para informar a data de vencimento) e
      um terceiro com o valor original da parcela. Inicializar a situação sempre como N.
       
      *Métodos
      + registrarAtraso – instancia a data de hoje e altera a situação para A, se a data de vencimento já passou em
      relação à data de hoje. Obviamente, esta alteração só será realizada se a parcela estiver na situação N.
      Método retorna true ou false, para indicar se houve ou não a mudança da situação.
       
      + pagar – método que será chamado por ocasião do pagamento da parcela.
      Esse método recebe como parâmetro a data em que está sendo feito o
      pagamento. Se a parcela estiver sendo paga com até 5 dias de atraso, pagará
      juros de 1% sobre o valor original; de 6 a 15 dias de atraso, juros de 1,5%; atraso
      acima de 15 dias, juros de 2,5%. O método deve atualizar os atributos situação
      e valor final, desta classe, além de registrar o pagamento da mesma no objeto
      Cliente, chamando o método daquela classe adequado para isso. Ao final, o
      método deve retornar o valor dos juros.
    • Kelison
      Pessoal preciso criar um código onde o usuário só possa ver o conteúdo do site B se ele chagar ao site B pelo link que tá no site A?
      Por Kelison
      Boa noite pessoal sou iniciante em php, e preciso criar um código onde o site "B" só exiba o conteúdo "1" se o usuário tiver chegado no site "B" clicando no link do site "A" que aponta para o site "B"
      Exemplo:
      Site A
      <html>
      <head> <head>
      <body>
      <a href="SITE-B">Ir para a site B</a>
      </body>
      </html>
      Caso á usuário tenha clicado no link do SITE "A" então ele exibe o conteúdo "1" no site "B" eu fazia isso com o código $_SERVER['HTTP_REFERER'];
      Onde ao carregar site "B" eu verificava com o if
       
      if($_SERVER['HTTP_REFERER']; == siteA) OK
       
      tava tudo dando certo, mas ontem eu comprei o certificado SSL para o SITE A, mas o site B não tem o certificado e o comando $_SERVER['HTTP_REFERER'];
      não funciona mais, fiz uns testes e descobri que $_SERVER['HTTP_REFERER']; não pega a referência se for do HTTPS para HTTP mais ao contrario funciona, o comando $_SERVER['HTTP_REFERER']; do site HTTP para o HTTPS funciona 
       
      como resolver esse problema lembrando que SITE A e SITE B estão no mesmo servido só muda o domínio 
       
      o que eu quero com isso é que se caso o usuário copiar a url e cole no campo endereço do navegador o SITE B não mostre o conteúdo "1" e se alguém colocar o link em outro site apontando para o site B ele também não exiba o conteúdo, o conteúdo só pode ser exibido caso o usuário primeiro passe pelo site A.
       
      Já pensei em session mais não sei como passar a session de um domínio para outro 
       
      alguém por favor tem alguma ideia para me ajudar desde já agradeço pela a ajuda.
×

Informação importante

Ao usar o fórum, você concorda com nossos Termos e condições.

  Aceito