得到错误：即使实现了所有虚拟方法，对`vtable for REDirect仍未定义的引用

问题描述 投票：-2回答：1

所以在正确的.cc文件中实现了所有虚拟功能后，我仍然无法使程序成功编译。这是实现文件：

#include "rd_direct.h"
#include "rd_error.h"

#include <string>
using std::string;

//General Functions
int rd_display(const string & name, const string & type, const string & mode)
{
    return RD_OK;
}

int rd_format(int xresolution, int yresolution)
{
    return RD_OK;
}

int rd_world_begin(void)
{
    return RD_OK;
}
int rd_world_end(void)
{
    return RD_OK;
}

int rd_frame_begin(int frame_no)
{
    return RD_OK;
}
int rd_frame_end(void)
{
    return RD_OK;
}


 int rd_render_init(void)
{
    return RD_OK;
}  

 int rd_render_cleanup(void)
{
    return RD_OK;
}

/**********Camera*************************/
int rd_camera_eye(const float eyepoint[3])
{
    return RD_OK;
}
int rd_camera_at(const float atpoint[3])
{
    return RD_OK;
}
int rd_camera_up(const float up[3])
{
    return RD_OK;
}
int rd_camera_fov(float fov)
{
    return RD_OK;
}
int rd_clipping(float znear, float zfar)
{
    return RD_OK;
}


/**********************   Transformations **********************************/

 int rd_translate(const float offset[3])
{
    return RD_OK;
}

 int rd_scale(const float scale_factor[3])
{
    return RD_OK;
}

 int rd_rotate_xy(float angle)
{
    return RD_OK;
}

 int rd_rotate_yz(float angle)
{
    return RD_OK;
}

 int rd_rotate_zx(float angle)
{
    return RD_OK;
}

 int rd_matrix(const float * mat)
{
    return RD_OK;
}


 int rd_xform_push(void)
{
    return RD_OK;
}

 int rd_xform_pop(void)
{
    return RD_OK;
}

/**********************   Geometric Objects  *******************************/

 int rd_bezier_curve(const string & vertex_type,
                  int degree, const float * vertex)
{
    return RD_OK;
}


 int rd_bezier_patch(const string & vertex_type,
                  int u_degree, int v_degree, 
                  const float * vertex)
{
    return RD_OK;
}


 int rd_catmull_clark_sds(const string & vertex_type,
                   float * coord, int nvertex,
                   int * vertex_list, int nface,
                   int * crease_list, int ncrease,
                   float *sharpness)
{
    return RD_OK;
}


 int rd_circle(const float center[3], float radius)
{
    return RD_OK;
}


 int rd_line(const float start[3], const float end[3])
{
    return RD_OK;
}


 int rd_lineset(const string & vertex_type,
             int nvertex, const float * vertex,
             int nseg, const int * seg)
{
    return RD_OK;
}


 int rd_point(const float p[3])
{
    return RD_OK;
}


 int rd_pointset(const string & vertex_type,
              int nvertex, const float * vertex)
{
    return RD_OK;
}

 int rd_polyset(const string & vertex_type, 
             int nvertex, const float * vertex,
             int nface,   const int * face)
{
    return RD_OK;
}


 int rd_cone(float height, float radius, float thetamax)
{
    return RD_OK;
}

 int rd_cube(void)
{
    return RD_OK;
}

 int rd_cylinder(float radius, float zmin, 
              float zmax, float thetamax)
{
    return RD_OK;
}

 int rd_disk(float height, float radius, float theta)
{
    return RD_OK;
}


 int rd_hyperboloid(const float start[3], const float end[3], 
                 float thetamax)
{
    return RD_OK;
}


 int rd_paraboloid(float rmax, float zmin, 
                float zmax, float thetamax)
{
    return RD_OK;
}

 int rd_sphere(float radius, float zmin, float zmax, float thetamax)
{
    return RD_OK;
}

 int rd_sqsphere(float radius, float north, float east, 
              float zmin, float zmax, float thetamax)
{
    return RD_OK;
}

 int rd_sqtorus(float radius1, float radius2, 
             float north, float east, float phimin, float phimax, 
             float thetamax)
{
    return RD_OK;
}

 int rd_torus(float radius1, float radius2, 
               float phimin, float phimax, float thetamax)
{
    return RD_OK;
}

 int rd_tube(const float start[3], const float end[3], float radius)
{
    return RD_OK;
}




  /********************  Lighting & Shading  ***************************/


int rd_background(const float color[])
{
    return RD_OK;
}
  // red, green, blue by default

int rd_color(const float color[])
{
    return RD_OK;
}

int rd_opacity(float opacity)
{
    return RD_OK;
}

int rd_emission(const float color[], float intensity)
{
    return RD_OK;
}

int rd_fill(const float seed_point[3])
{
    return RD_OK;
}

int rd_surface(const string & shader_type)
{
    return RD_OK;
}

int rd_cone_light(const float pos[3], const float at[3], 
                float theta_min, float theta_max,
                const float color[], float intensity)
{
    return RD_OK;
}

int rd_point_light(const float pos[3], 
                 const float color[], float intensity)
{
    return RD_OK;
}

int rd_far_light  (const float dir[3], 
                 const float color[], float intensity)
{
    return RD_OK;
}

int rd_ambient_light(const float color[], float intensity)
{
    return RD_OK;
}


int rd_specular_color(const float color[], int exponent)
{
    return RD_OK;
}

int rd_k_ambient(float Ka)
{
    return RD_OK;
}
int rd_k_diffuse(float Kd)
{
    return RD_OK;
}
int rd_k_emission(float Ke)
{
    return RD_OK;
}
int rd_k_specular(float Ks)
{
    return RD_OK;
}

int rd_attribute_push(void)
{
    return RD_OK;
}
int rd_attribute_pop(void)
{
    return RD_OK;
}


int rd_map_border(const string & map_type,
                const string & horizontal, 
                const string & vertical)
{
    return RD_OK;
}

int rd_map_bound(const string & map_type,
               float s_min, float t_min, 
               float s_max, float t_max)
{
    return RD_OK;
}

int rd_map_load(const string & filename, 
              const string & label)
{
    return RD_OK;
}

int rd_map_sample(const string & map_type,
                const string & intra_level, 
                const string & inter_level)
{
    return RD_OK;
}

int rd_map(const string & map_type, const string & label)
{
    return RD_OK;
}



  /****************************  Options  **********************************/

int rd_option_array(const string & name, int n, const float *values)
{
    return RD_OK;
}


int rd_option_bool(const string & name, bool flag)
{
    return RD_OK;
}


int rd_option_list(const string & name, int n, const string values [])
{
    return RD_OK;
}


int rd_option_real(const string & name, float value)
{
    return RD_OK;
}


int rd_option_string(const string & name, const string & value)
{
    return RD_OK;
}


int rd_custom(const string & label)
{
    return RD_OK;
}

这是.cc从中提取的我的.h文件：


#ifndef RD_BASE_ENGINE_H
#define RD_BASE_ENGINE_H

#include <string>
using std::string;

class RenderEngine
{
public:

  /**********************   General functions  *******************************/

  virtual int rd_display(const string & name, const string & type, 
             const string & mode);

  virtual int rd_format(int xresolution, int yresolution);

  virtual int rd_world_begin(void);
  virtual int rd_world_end(void);

  virtual int rd_frame_begin(int frame_no);
  virtual int rd_frame_end(void);

  virtual int rd_render_init(void);  /* Initialize renderer */
  virtual int rd_render_cleanup(void);

  /**********************   Camera  ******************************************/

  virtual int rd_camera_eye(const float eyepoint[3]);
  virtual int rd_camera_at(const float atpoint[3]);
  virtual int rd_camera_up(const float up[3]);
  virtual int rd_camera_fov(float fov);
  virtual int rd_clipping(float znear, float zfar);

  /**********************   Transformations **********************************/

  virtual int rd_translate(const float offset[3]);
  virtual int rd_scale(const float scale_factor[3]);
  virtual int rd_rotate_xy(float angle);
  virtual int rd_rotate_yz(float angle);
  virtual int rd_rotate_zx(float angle);
  virtual int rd_matrix(const float * mat);

  virtual int rd_xform_push(void);
  virtual int rd_xform_pop(void);

  /**********************   Geometric Objects  *******************************/

  virtual int rd_bezier_curve(const string & vertex_type,
                  int degree, const float * vertex);

  virtual int rd_bezier_patch(const string & vertex_type,
                  int u_degree, int v_degree, 
                  const float * vertex);

  virtual int rd_catmull_clark_sds(const string & vertex_type,
                   float * coord, int nvertex,
                   int * vertex_list, int nface,
                   int * crease_list, int ncrease,
                   float *sharpness);

  virtual int rd_circle(const float center[3], float radius);

  virtual int rd_line(const float start[3], const float end[3]);

  virtual int rd_lineset(const string & vertex_type,
             int nvertex, const float * vertex,
             int nseg, const int * seg);

  virtual int rd_point(const float p[3]);

  virtual int rd_pointset(const string & vertex_type,
              int nvertex, const float * vertex);
  virtual int rd_polyset(const string & vertex_type, 
             int nvertex, const float * vertex,
             int nface,   const int * face);

  virtual int rd_cone(float height, float radius, float thetamax);
  virtual int rd_cube(void);
  virtual int rd_cylinder(float radius, float zmin, 
              float zmax, float thetamax);
  virtual int rd_disk(float height, float radius, float theta);

  virtual int rd_hyperboloid(const float start[3], const float end[3], 
                 float thetamax); 

  virtual int rd_paraboloid(float rmax, float zmin, 
                float zmax, float thetamax);
  virtual int rd_sphere(float radius, float zmin, float zmax, float thetamax);
  virtual int rd_sqsphere(float radius, float north, float east, 
              float zmin, float zmax, float thetamax); 
  virtual int rd_sqtorus(float radius1, float radius2, 
             float north, float east, float phimin, float phimax, 
             float thetamax);
  virtual int rd_torus(float radius1, float radius2, 
               float phimin, float phimax, float thetamax);
  virtual int rd_tube(const float start[3], const float end[3], float radius);



  /********************  Lighting & Shading  ***************************/

  virtual int rd_background(const float color[]);
  // red, green, blue by default

  virtual int rd_color(const float color[]);

  virtual int rd_opacity(float opacity);

  virtual int rd_emission(const float color[], float intensity);

  virtual int rd_fill(const float seed_point[3]);

  virtual int rd_surface(const string & shader_type);

  virtual int rd_cone_light(const float pos[3], const float at[3], 
                float theta_min, float theta_max,
                const float color[], float intensity);

  virtual int rd_point_light(const float pos[3], 
                 const float color[], float intensity);

  virtual int rd_far_light  (const float dir[3], 
                 const float color[], float intensity);

  virtual int rd_ambient_light(const float color[], float intensity);


  virtual int rd_specular_color(const float color[], int exponent);

  virtual int rd_k_ambient(float Ka);
  virtual int rd_k_diffuse(float Kd);
  virtual int rd_k_emission(float Ke);
  virtual int rd_k_specular(float Ks);

  virtual int rd_attribute_push(void);
  virtual int rd_attribute_pop(void);

  /****************************   Mapping ******************************/

  virtual int rd_map_border(const string & map_type,
                const string & horizontal, 
                const string & vertical);
  virtual int rd_map_bound(const string & map_type,
               float s_min, float t_min, 
               float s_max, float t_max);
  virtual int rd_map_load(const string & filename, 
              const string & label);
  virtual int rd_map_sample(const string & map_type,
                const string & intra_level, 
                const string & inter_level);
  virtual int rd_map(const string & map_type, const string & label);


  /****************************  Options  **********************************/

  virtual int rd_option_array(const string & name, int n, const float *values);

  virtual int rd_option_bool(const string & name, bool flag);

  virtual int rd_option_list(const string & name, int n, const string values []);

  virtual int rd_option_real(const string & name, float value);

  virtual int rd_option_string(const string & name, const string & value);

  virtual int rd_custom(const string & label);

  virtual ~RenderEngine();
};


// Some useful helper functions
int get_vertex_size(const string & vertex_type);
// Returns the number of components in an attributed vertex type

#endif /* RD_BASE_ENGINE_H */

我已经看到此错误的StackOverflow线程，但这不能解决我的问题。如果有人可以帮助我，那会很棒，因为我很茫然。完整的错误代码在这里：

$ make
g++ -o rd_view -g -Wall libcs631.a rd_direct.o pnm_display.o -lm -lX11
libcs631.a(rd_engine.o):rd_engine.cc:(.rdata$.refptr._ZTV8REDirect[.refptr._ZTV8REDirect]+0x0): undefined reference to `vtable for REDirect'
collect2: error: ld returned 1 exit status
make: *** [Makefile:5: rd_view] Error 1

编辑：这是我的头文件，其中定义了REDirect类：

#ifndef RD_ENGINE_DIRECT_H
#define RD_ENGINE_DIRECT_H

#include "rd_enginebase.h"
#include "rd_error.h"

#include <string>
using std::string;

// This is a rendering engine that renders directly to the image buffer as
// primitives come in.  A depth buffer is obviously needed.  Transparency is
// not properly handled.

class REDirect: public RenderEngine
{
 public:

        int rd_display(const string & name, const string & type, const string & mode);
};

#endif /* RD_ENGINE_DIRECT_H */

'''
c++ makefile
1个回答
0
投票

定义

int rd_display(const string & name, const string & type, const string & mode) { ... }

是一个免费功能。您需要告诉编译器那些功能是某个类的成员的实现：

int RenderEngine::rd_display(const string & name, const string & type, const string & mode) { ... }

因此，只需将RenderEngine::添加到所有这些功能。

并且也不要忘记实现虚拟析构函数，或将其声明为

virtual ~RenderEngine() = default;

让编译器生成一个。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.