Unresolved external symbol

  • (5 Pages)
  • +
  • 1
  • 2
  • 3
  • Last »

60 Replies - 9501 Views - Last Post: 19 June 2014 - 07:14 AM Rate Topic: -----

#1 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Unresolved external symbol

Posted 22 May 2014 - 02:27 AM

Hello DIC community! (I should probably avoid using that acronym..)


So basically, although I've never written C++, I was given the task of compiling a bunch of .cpp projects. Sounds pretty simple, except not. I've compiled the first 2, but the 3rd one requires some extra .dlls and libraries and headers, which I already added to the solution, paths, etc. I supposedly already set it all up to be able to run, but alas:

1>------ Build started: Project: tutorial02_Q4 (Visual Studio 2010), Configuration: Debug Win32 ------
1>main.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) void __cdecl cm2::triamesh::registration(char const *,char const *)" ([email protected]@[email protected]@[email protected]) referenced in function _main
1>main.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) void __cdecl cm2::quadmesh::registration(char const *,char const *)" ([email protected]@[email protected]@[email protected]) referenced in function _main
1>..\..\..\libs\DebugWin32\tutorial02_Q4.exe : fatal error LNK1120: 2 unresolved externals
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========



Someone told me the program couldn't find a specific .dll, but which one?? I've tried Ctrl + F'ing the keyword "declspec" in the whole project and it leads me to this:

// Define CM2FEMIMPORT, CM2FEMEXPORT, CM2FEMLOCAL and CM2FEMPUBLIC.
#if (defined(WIN32) | defined(WIN64))
   #if defined(_USRDLL)
      #define CM2FEMEXPORT __declspec(dllexport)
   #else
      #define CM2FEMEXPORT
   #endif
   #if defined(CM2_LIBIMPORT)
      #define CM2FEMIMPORT
   #else
      #define CM2FEMIMPORT __declspec(dllimport)
   #endif
   #define CM2FEMLOCAL
   #define CM2FEMPUBLIC
#elif defined(CM2_GCC_HASCLASSVISIBILITY)
   #define CM2FEMIMPORT
   #define CM2FEMEXPORT __attribute__ ((visibility("default")))
   #define CM2FEMLOCAL __attribute__ ((visibility("hidden")))
   #define CM2FEMPUBLIC __attribute__ ((visibility("default")))
#else
   #define CM2FEMIMPORT
   #define CM2FEMEXPORT
   #define CM2FEMLOCAL
   #define CM2FEMPUBLIC
#endif

// Define CM2FEM_API for DLL builds
#ifdef CM2FEM_EXPORTS
   #define CM2FEM_API CM2FEMEXPORT
#else
   #define CM2FEM_API CM2FEMIMPORT
#endif


Thanks in advance.

Is This A Good Question/Topic? 0
  • +

Replies To: Unresolved external symbol

#2 AmitTheInfinity  Icon User is offline

  • C Surfing ∞
  • member icon

Reputation: 119
  • View blog
  • Posts: 1,565
  • Joined: 25-January 07

Re: Unresolved external symbol

Posted 22 May 2014 - 02:57 AM

Check for "CM2 MeshTools" related code/library you have in your project. It's not able to locate "triamesh" and "quadmesh" related stuff.
Was This Post Helpful? 1
  • +
  • -

#3 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 03:30 AM

Thank you Amit. I proceeded as you suggested. In the whole solution, I found this in main.cpp:

Spoiler



The keyword is referenced in other files, such as converters1d.h and converters2d.h, I can only assume this is related to the construction simulation software of the company I'm interning on.

In mesher_t3.h there's this:

namespace triamesh { 

/**
   Unstructured triangle %mesher.

   \image html tmsh2d09t.png "Example of mesh generated by CM2 TriaMesh."

   Instances of this class generate triangle meshes on any 2-D domains defined 
   by some boundary edges and possibly some (isolated) internal edges and nodes.
 
   They can also be used as shape optimizers of an already existing triangle mesh.

   All the data to be passed to the %mesher are gathered into a single 
   structure of type triamesh::mesher::data_type.

   Example:
   \verbatim

   Mesh of a square

   INPUT:
                                                 3               2
      data.pos = [0 4 4 0                         *-------------*
                  0 0 4 4]                        |             |
                                                  |             |
      data.connectB = [0 1 2 3                    |             |
                       1 2 3 0]                   |             |
                                                  |             |
                                                  |             |
                                                  |             |
                                                  *-------------*
                                                 0               1


   triamesh::mesher   my_mesher;
   my_mesher.run (data);


   OUTPUT:
                                                 3               2
      data.pos = [0  4  4  0  2                   *-------------*
                  0  0  4  4  2]                  |\           /|
                                                  |  \       /  |
      data.connectM = [0 4 3 0                    |    \ 4 /    |
                       1 1 4 4                    |      *      |
                       4 2 2 3]                   |    /   \    |
                                                  |  /       \  |
          (indices may vary)                      |/           \|
                                                  *-------------*
                                                 0               1
   \endverbatim

   \note       Upon entry, the boundary edges in \p data.connectB need to be ordered the same way 
               in the case of several subdomains, or when internal closed lines (such as holes) are prescribed.
               However, edges don't need to be consecutive in the matrix.
   \note       Upon exit, the elements are always oriented counter-clockwise, i.e. with the normal = Oz.
   \note       Thread safe.
   \warning    The third coordinates in matrix \p data.pos is discarded for all points.
               That means that all points are projected onto the Z=0 plane (even for points
               not referenced in \p data.connectB or \p data.isolated_nodes).
   \see        meshtools2d::mesh_struct_T3, quadmesh::mesher, triamesh_aniso::mesher.
   */
class CM2TRIAMESH_API mesher
{
public:

   /**
      This generator is for triangle meshes.
      */
   enum
   {
      generated_FE_type = CM2_FACET3         //!< Generates all-triangle meshes (CM2_FACET3).
   };


   /**
      Operating mode type for triamesh::mesher.

      This structure gathers flags and parameters to control the way the triamesh::mesher works.
      */
   struct CM2TRIAMESH_API operating_mode_type
   {

   /**
      Typedef for the display handler.

      \param[in]  pass_thru   The \ref operating_mode_type::pass_thru pointer (user provided).
      \param[in]  level       The importance of the message: 
                                 -  0 = Basic message.
                                 -  1 = Somewhat detailed message.
                                 -  2 = Very detailed message (DEBUG mode only).
      \param[in]  msg         The message.
      */
   typedef void (*display_handler_type) (void* pass_thru, unsigned level, const char* msg);

   /**
      Typedef for the interrupt handler.

      The interrupt handler, if any, is called internally by the %mesher from time to time 
      to ask for an interruption (when the handler returns \c true) or to continue 
      the meshing process (when the handler returns \c false).

      \param[in]  pass_thru   The \ref operating_mode_type::pass_thru pointer (user provided).
      \param[in]  progress    Value (between 0 = just starting and 1 = meshing is complete) 
                              to give an estimate of the progress of the meshing.
      */
   typedef bool (*interrupt_handler_type) (void* pass_thru, double progress);


   /**
      Basic mode for the %mesher.
      */
   enum basic_mode_type
   { 
      MESH_MODE,                //!< Normal mode of the %mesher (generates a new mesh).
      REGULARIZE_MODE,          //!< Takes an input mesh and optimizes it (nodes are added, removed, smoothed, connectivity is changed).
      CONVEX_HULL_MODE          //!< Produces an approximate convex hull of a set of points.
   };


   /**
      Default constructor.

      The default values are:
         - \ref basic_mode = \ref MESH_MODE 
         - \ref strict_constraints_flag = \c true
         - \ref subdomains_forcing = \c 0
         - \ref refine_flag = \c true
         - \ref use_default_background_mesh_flag = \c false
         - \ref reset_external_boundaries_flag = \c false
         - \ref node_smoothing_flag = \c true
         - \ref node_inserting_flag = \c true
         - \ref node_removing_flag = \c true
         - \ref shell_remeshing_flag = \c true
         - \ref no_clamped_edges_flag = \c false
         - \ref compute_Qh_flag = \c false
         - \ref structured_pattern = \c -1
         - \ref multi_structured_flag = \c false
         - \ref nodes_limit = \c UINT_MAX
         - \ref optim_level = \c 3
         - \ref target_metric = \c 0.0
         - \ref max_gradation = \c 0.5
         - \ref shape_quality_weight = \c 0.60
         - \ref length_upper_bound = \c 1.414
         - \ref display_hdl = \c NULL
         - \ref interrupt_hdl = \c NULL
         - \ref pass_thru = \c NULL
         - \ref progress_start = \c 0.0
         - \ref progress_range = \c 1.0
      */
   operating_mode_type()
      : basic_mode(MESH_MODE), 
        strict_constraints_flag(true), subdomains_forcing(0), refine_flag(true), 
        use_default_background_mesh_flag(false), reset_external_boundaries_flag(false), 
        node_smoothing_flag(true), node_inserting_flag(true), node_removing_flag(true), 
        shell_remeshing_flag(true), no_clamped_edges_flag(false), 
        compute_Qh_flag(false), structured_pattern(-1), multi_structured_flag(false),
        nodes_limit(UINT_MAX), optim_level(3u),
        target_metric(0.0), max_gradation(0.5),
        shape_quality_weight(0.60), length_upper_bound(1.414),
        display_hdl(NULL), interrupt_hdl(NULL), pass_thru(NULL),
        progress_start(0.0), progress_range(1.0)
   { }

   /**
      Returns \c true if the sanity check is successful.
      */
   bool
   valid() const        { return this->check() == 0; }

   /**
      Carries out a sanity check of the mode's fields.

      \return        Returns a negative value in case of error.
                     Returned value = -k => the k-th field of the structure is illegal.
                     (\ref basic_mode is the first field, \ref strict_constraints_flag is the second...)
      */
   int
   check() const;

   /**
      Resets to the \link cm2::triamesh::mesher::operating_mode_type::operating_mode_type() default values \endlink.
      */
   void
   reset();


   /**
      Basic operating mode of the %mesher: \ref MESH_MODE, \ref REGULARIZE_MODE or \ref CONVEX_HULL_MODE.

      Default = \ref MESH_MODE.
      */
   basic_mode_type         basic_mode;

   /**
      Flag for strict enforcement of hard edges and hard nodes.

      If \c true, an error is raised in the following cases:
         -  Two hard nodes are coincident (same coordinates).
         -  Two hard edges cut each other.
         -  A hard node is inside a hard edge.
         -  A hard node is outside the domain.
         -  A hard edge is outside the domain.

      If \c false, the above cases raise only a warning and one of the erroneous item is discarded.

      \note    When strict_constraints_flag = false, the lowest edges in connectB are privileged for enforcement.
      \note    Used only in \ref MESH_MODE.

      Default = \c true.
      */
   bool                    strict_constraints_flag;

   /**
      Forcing mode for intern subdomains.
      
      Possible values are:
         -  -1    : All intern subdomains are considered as holes regardless of the orientation of
                    their enclosing boundary.
         -   0    : Intern subdomains are considered as holes when the orientation of
                    their enclosing boundary is opposite to the orientation of the most enclosing domain.<br>
                    Otherwise, they are meshed.
         -  +1    : All intern subdomains are meshed regardless of the orientation of
                    their enclosing boundary.

      \note    Used only in \ref MESH_MODE.

      Default = \c 0.
      */
   int                     subdomains_forcing;

   /**
      Flag to enable refinement. 

      If \c false, triangulates with the hard nodes only.

      If \c true, adds new nodes inside the domain to achieve good shape and size qualities.

      \note    Not used in \ref CONVEX_HULL_MODE.

      Default = \c true.
      */
   bool                    refine_flag;

   /**
      Flag to tell the %mesher to use the default background mesh for the interpolation
      of the metric values. 

      For expert users only.

      The default background mesh is the "front" mesh, i.e. the mesh of the triangulation of the hard nodes
      without any new node.

      If set to \c false, the background mesh used to interpolate the metrics is the mesh currently processed.

      \warning A user-defined background mesh supersedes the default background mesh, even
               with this flag set.
      \note    For expert users only.
      \note    Using the current mesh is the fastest mode which indeed gives a similar accuracy,
               so it is recommended to leave this flag to false.

      Default = \c false.
      */
   bool                    use_default_background_mesh_flag;

   /**
      Flag to compute the external boundaries. 

      This flag can be useful to optimize a pre-existing mesh with no boundary mesh available.

      When set to \c true, the external edge mesh (\ref data_type::connectB) is computed using the input triangle mesh 
      (\ref data_type::connectM).

      \note    The orientation of the edges in \ref data_type::connectB
               matches the orientation of the elements.
      \note    Set \ref optim_level to 0 to get the boundary mesh of a triangle mesh
               without any change on it.
      \note    Not used in \ref MESH_MODE.

      Default = \c false.
      */
   bool                    reset_external_boundaries_flag;

   /**
      Flag to allow the node-smoothing scheme in the optimization step. 

      It can be useful in \ref REGULARIZE_MODE to set this flag to \c false
      to freeze the positions of the nodes.

      \note    Node smoothing doesn't change the mesh connectivity, only the coordinates of nodes.
      \note    This option, as part of the optimization step, is taken into account only when optim_level > 0.
      \note    Used in \ref MESH_MODE and \ref REGULARIZE_MODE.

      Default = \c true.
      */
   bool                    node_smoothing_flag;

   /**
      Flag to allow the node-inserting scheme in the optimization step. 
      
      \note    Node inserting increases the number of nodes, changes the mesh 
               connectivity, but doesn't change the other nodes' coordinates.
      \note    This option, as part of the optimization step, is taken into account only when optim_level > 0.
      \note    Used in \ref MESH_MODE and \ref REGULARIZE_MODE.

      Default = \c true.
      */
   bool                    node_inserting_flag;

   /**
      Flag to allow the node-removing scheme in the optimization step. 

      \note    Node removing decreases the number of nodes, changes the mesh 
               connectivity, but doesn't change the other nodes' coordinates.
      \note    This option, as part of the optimization step, is taken into account only when optim_level > 0.
      \note    Used in \ref MESH_MODE and \ref REGULARIZE_MODE.

      Default = \c true.
      */
   bool                    node_removing_flag;

   /**
      Flag to allow the edge-swapping scheme in the optimization step. 

      \note    Edge swapping changes the mesh connectivity,
               but doesn't change the number of nodes nor their coordinates.
      \note    This option, as part of the optimization step, is taken into account only when optim_level > 0.
      \note    Used in \ref MESH_MODE and \ref REGULARIZE_MODE.

      Default = \c true.
      */
   bool                    shell_remeshing_flag;

   /**
      Flag to force the removing of all free edges with two hard nodes.
      
      This is a special node-inserting scheme dedicated to breaking the non-hard edges with two hard nodes.

      \note    This option supersedes node_inserting_flag.
               It increases the number of nodes, changes the mesh 
               connectivity, but doesn't change the other nodes' coordinates.
      \note    Setting this flag to \c true increases the number of generated nodes and elements, and can
               reduce the global quality of the mesh (elements' shape quality and elements' size).
      \note    This option, as part of the optimization step, is taken into account only when optim_level > 0.

      Default = \c false
      */
   bool                    no_clamped_edges_flag;

   /**
      Flag to compute the edge quality histogram (quality in term of edge length).

      \note    Not used in \ref CONVEX_HULL_MODE.

      Default = \c false.
      */
   bool                    compute_Qh_flag;

   /**
      Meshing mode on rectangular domains (unstructured or structured meshes).

      Three types of structured meshes:
      \verbatim
         - Left pattern:

               *------*------* 
               | \    | \    |
               |   \  |   \  |
               |     \|     \|
               *------*------*
               | \    |\     |
               |   \  |  \   |
               |     \|    \ |
               *------*------*

         - Right pattern:

               *------*------* 
               |     /|     /|
               |   /  |   /  |
               | /    | /    |
               *------*------*
               |     /|     /|
               |   /  |   /  |
               | /    | /    |
               *------*------*


         - "Union Jack" pattern:        

               *------*------* 
               | \    |    / |
               |   \  |  /   |
               |     \|/     |
               *------*------*
               |     /|\     |
               |   /  |  \   |
               | /    |    \ |
               *------*------*
      \endverbatim

      Possible values are:
         -  -1    : Always use the frontal algorithm (generates unstructured meshes).
         -   0    : When possible, generates structured left-oriented meshes (simply oriented pattern).
         -   1    : When possible, generates structured right-oriented meshes (simply oriented pattern).
         -  >= 2  : When possible, generates structured UJ meshes ("Union Jack" pattern).

      \note    Structured meshes can be generated only when:
                  - The domain is topologically rectangular (four sharp corners).
                  - The discretizations of the four lines match 
                    (same number and similar elements along lower and upper, right and left).
                  - The domain is convex.
                  - There is no internal hard edge or node.
                  - There is no repulsive point.

      \note    Used only when refine_flag = \c true.
      \note    Used in \ref MESH_MODE only.

      Default = -1 (always unstructured mesh).
      */
   int                     structured_pattern;

   /**
      Flag to trigger the multi-structured-part analysis.

      This analysis performs a more complete search for structurable subdomains than normally
      (at the price of a lower speed).

      With this flag on, several rectangular subdomains can be meshed structurably, whereas it is not
      always the case with this flag down.

      \note    Used only when refine_flag = \c true and structured_pattern != -1.
      \note    Used in \ref MESH_MODE only.

      Default = \c false.
      */
   bool                    multi_structured_flag;

   /**
      Maximum authorized number of nodes.

      Default = \c UINT_MAX.
      */
   unsigned                nodes_limit;

   /**
      Optimization level between 0 and 10.

      Control the trade-off between speed and element quality.
      The higher the optim level, the more aggressive the optimization algorithms.

      \note    The algorithms involved here aim at optimizing both the shape quality of the elements \em and their size 
               quality (length of elements' edges). Hence, increasing the value of optim_level may lead sometimes to a (small)
               reduction in the shape qualities (min, average or max value) whereas the \em global quality (which takes into 
               account both types of quality) gets better. 
      \note    The \ref shape_quality_weight parameter controls the weight of the shape quality in the global 
               quality measure.
      \note    Level 0 disables any optimization.

      Default = 3
      */
   unsigned                optim_level;

   /**
      Element size inside the domain.

      The elements size tends toward this value as they get away from the hard (boundary) edges. 
      
      \warning Disabled when target_metric <= 0.
      \warning Disabled when a structured mesh can be done.
      \warning Disabled when a background mesh is used.
      \warning Disabled when use_default_background_mesh_flag = true.
      \note    This parameter is often used to reduce the total number of elements
               (when target_metric > default sizes based on boundary edge lengths) 
               and to save FEM computation time without loosing much on element shape quality.
      \note    The target_metric may be smaller or bigger than the default sizes based on boundary edge lengths.
      \note    target_metric >= 0.
      \note    Used in MESH_MODE only.
      \see     max_gradation, structured_pattern.

      Default = 0.0 (disabled)
      */
   double                  target_metric;

   /**
      This parameter controls the gradation of the elements size from the boundary sizes 
      to the size defined by \ref target_metric inside the domain. 

      A value close to 0 leads to a more progressive variation of mesh size (smoother).

      \warning Disabled when target_metric <= 0.
      \warning Disabled when a structured mesh can be done.
      \warning Disabled when a background mesh is used.
      \warning Disabled when use_default_background_mesh_flag = true.
      \note    max_gradation >= 0.
      \note    Used in MESH_MODE only.
      \see     target_metric, structured_pattern.

      Default = 0.5
      */
   double                  max_gradation;

   /**
      Weight on shape qualities versus size qualities.

      Scalar between 0 and 1 indicating the importance of the shape qualities versus
      the size quality for the regularization step:
         - For values greater than 0.5, the shape quality is privileged.
         - For values lesser than 0.5, the size quality is privileged.

      Default = 0.6 (slight preference for shape quality). Should not normally be changed.

      \pre        shape_quality_weight >= 0.
      \pre        shape_quality_weight <= 1.
      */
   double                  shape_quality_weight;

   /**
      Upper bound value for the edge lengths in the final mesh.

      The mesher tends to generate meshes with no edge longer than this value (normalized length).
      But this is \em not a strict enforcement. Most of the edges will be shorter than this limit, 
      but some may remain somewhat longer.

      The default value (1.414) gives the optimal meshes with respect to the size qualities.
      With this default value (no edge more than 41% longer than the perfect length), 
      the average edge length tends to be 1.

      Sometimes it can be useful to limit the length of the edges to a shorter value (usually between 1 and 1.414),
      and to accept a mean value smaller than 1 (sub-optimal edge qualities). 

      \note    The value is \em relative to the perfect edge length.

      Default = 1.414
      */
   double                  length_upper_bound;

   /**
      The user-provided display function for verbose.

      Level of message: 
         -  0 = Basic message.
         -  1 = Somewhat detailed message.
         -  2 = Very detailed message (debug mode only).

      Default = \c NULL.
      */
   display_handler_type    display_hdl;

   /**
      The user-provided interrupt function.

      When this function returns \c true, the process is stopped. 
      This can abort the mesh (if the interruption occured at an early stage),
      or result in a mesh of poor quality (if the %mesher was in the refinement or optimization 
      stage when the interruption occurs).

      The parameter \c progress (between 0 and 1) gives a hint about the progress
      of the meshing.

      Default = \c NULL.
      */
   interrupt_handler_type  interrupt_hdl;

   /**
      The pointer that will be passed to the \ref display_hdl and \ref interrupt_hdl
      (if any) when called by the mesher.

      Example:
      \code
         void my_display_hdl (void* pass_thru, unsigned level, const char* msg)
         {
            window_type*   my_window = static_cast<window_type*> (pass_thru);
            my_window.show (msg);
         }

         mesher         my_mesher;
         data_type      my_mesh_data (pos, connectB);
         window_type    my_window;                    // A window instance.
         my_mesher.mode.display_hdl = &my_display_hdl;
         my_mesher.mode.pass_thru = static_cast<void*> (&my_window);   
         my_mesher.run (my_mesh_data);                // Will call my_display_hdl.
      \endcode
      */
   void*                   pass_thru;

   /**
      The start value for the progress parameter sent to the interrupt handler.

      Default = \c 0.0
      */
   double                  progress_start;

   /**
      The range for the progress parameter sent to the interrupt handler.

      The end value equals to progress_start + progress_range.

      Default = \c 1.0
      */
   double                  progress_range;

   };    // operating_mode_type



   /**
      The data type for triamesh::mesher.

      This structure is used to gather all the input and output data of the function 
      triamesh::mesher::run.
      */
   struct CM2TRIAMESH_API data_type
   {

   /// The display handler type.
   typedef operating_mode_type::display_handler_type        display_handler_type;


   /**
      Warning enums for the %mesher.

      Non fatal warnings.

      If such a warning is raised (returned in the field \ref warning_code),
      the %mesher is not stopped but the user shall check its input and output data for a potential
      mistake.
      */
   enum warning_type
   { 
      CM2_NO_WARNING                =   0,   //!< OK, no warning.
      CM2_INTERRUPTION              = -10,   //!< The process has been interrupted (by the user through the interrupt handler).
      CM2_NODES_LIMIT_WARNING       = -11,   //!< The limitation on the number of nodes has been reached.
      CM2_NODE_DISCARDED            = -12,   //!< Two nodes are too close to each other (same position or almost) or some are located outside. 
      CM2_EDGE_DISCARDED            = -13,   //!< A hard edge is cut by another hard edge, or has a hard node inside it, or is located outside.  
      CM2_SHAPE_QUALITY_WARNING     = -14    //!< One or several elements have a bad quality (Qs < 0.01).
   };

   /**
      Error enums for the %mesher.

      Fatal errors.

      If such an error is raised (returned in the field \ref error_code),
      the %mesher is stopped and no final mesh is returned.
      */
   enum error_type
   { 
      CM2_NO_ERROR                  =    0,  //!< OK, no error.
      CM2_LICENSE_ERROR             = -100,  //!< Invalid or expired license.
      CM2_MODE_ERROR                = -101,  //!< Error in operating mode.
      CM2_DATA_ERROR                = -102,  //!< Error in input data (NaN, INF, error in dimensions of arrays...)
      CM2_NODES_LIMIT_ERROR         = -103,  //!< The limitation on the number of nodes is too tight.
      CM2_NODE_ERROR                = -104,  //!< Two nodes are too close to each other (same position or almost) or some are located outside. 
      CM2_EDGE_ERROR                = -105,  //!< A hard edge is cut by another hard edge, or has a hard node inside it, or is located outside.  
      CM2_BOUNDARY_ERROR            = -106,  //!< Illegal boundaries provided by the user (boundary not closed, boundary Xings, empty domain...) 
      CM2_DEGENERATED_ELEMENT       = -107,  //!< The process leads to some degenerated elements and therefore the %mesher cannot build a valid mesh.
      CM2_BACKGROUND_MESH_ERROR     = -108,  //!< The background mesh is not valid (bad dimensions, bad indices, bad associated metrics, degenerated elements...)
      CM2_SYSTEM_MEMORY_ERROR       = -199,  //!< Insufficient memory available.
      CM2_INTERNAL_ERROR            = -200   //!< Something went wrong but don't know what (please contact [email protected]).
   };


   /**
      The type of metric.

      This mesh generator is \em isotropic and the metrics are scalars.
     */
   typedef double             metric_type;

   /**
      The array type for the metric values.

      This mesh generator is \em isotropic and the metrics are represented as single scalars (\c double values).
      */
   typedef DoubleVec          metrics_type;



   /// Default constructor.
   data_type()                            { this->clear(); }

   /**
      Copy constructor (hard copy).
      All matrices are hard copied.
      */
   data_type (const data_type& cpy)       { (*this) = cpy; }

   /**
      Constructor.

      Constructs the data with a coordinates matrix and a boundary edges matrix (hard copy).

      This is the simplest way to create the data to exchange with the %mesher.

      \param   P           The coordinates matrix. New nodes are appended by the %mesher.
      \param   connectE2   The connectivity matrix for the boundary mesh.

      \note    After the meshing process, you must get the new coordinate matrix from the field \ref pos,
               and the connectivity matrix \ref connectM as well, or use the \ref extract function.
      \warning Upon exit, the matrix data.pos is resized to two rows. 
               The third coordinate (i.e. Z) is lost for all points.
      */
   data_type (DoubleMat& P, UIntMat& connectE2)
   {
      this->clear();
      this->pos.shallow_copy (P);
      this->connectB.shallow_copy (connectE2);
   }


   /**@name Copy members */
   //@{
   /// Copy operator (hard copy).
   const data_type&
   operator= (const data_type& data);

   /// Shallow copy.
   void
   shallow_copy (const data_type& data);
   //@}


   /**
      Returns true if the sanity check is successful.
      */
   bool
   valid() const        { return this->check() == 0; }

   /**
      Carries out a sanity check of the input fields.

      \return        Returns a negative value in case of error.
                     Returned value = -k => the k-th field of the structure is illegal
                     (\ref pos is the first field, \ref connectB is the second...)
      */
   int
   check() const;

   /// Shallow copy.
   void
   extract (DoubleMat& P, UIntMat& connectT3) const
      { P = this->pos; connectT3 = this->connectM; }

   /// Shallow copy. Provided for compatibility with quadmesh::mesher.
   void
   extract (DoubleMat& P, UIntMat& connectQ4, UIntMat& connectT3) const
      { P = this->pos; connectQ4.clear(); connectT3 = this->connectM; }

   /// Clears all fields and reinit to default values.
   void
   clear();

   /// Clears only the output fields.
   void
   clear_data_out();

   /**
      Prints information about the mesh using a display handler.

      \param   hdl   The display handler.

      \note    The first parameter of the handler (param \c pass_thru) is irrelevant
               (\c NULL).
      */
   void
   print_info (display_handler_type hdl) const;

   /**
      Saves the data into a file.

      \param   filename       The file name for the output (overwrite mode).
      \param   precision      The precision of the output for the floating-point values.
      */
   void
   save (const char* filename, unsigned precision = 16) const;

   /**
      Load the data from a file.
      This member is the reciprocal of the save member above.

      \param   filename       The file name for the intput.

      \return  Error code (negative value = error).
      */
   int
   load (const char* filename);

   /// Checks if an error has been raised.
   inline bool
   error_raised() const       { return this->error_code != CM2_NO_ERROR; }

   /// Checks if a warning has been raised.
   inline bool
   warning_raised() const     { return this->warning_code != CM2_NO_WARNING; }


   /**
      The coordinates matrix (column oriented).

      Node \c i has coordinates in column \c i.

      Upon entry, this matrix must contains the coordinates of all the points (i.e. nodes referenced in 
      \ref connectB, \ref isolated_nodes, \ref background_mesh and \ref repulsive_points). 

      It may also contain other unreferenced points.

      Upon exit, the new nodes are appended at the back of the matrix and the indices in the
      final mesh (\ref connectM) refer to column numbers in this matrix.

      Mode = IN-OUT in operating_mode_type::MESH_MODE and operating_mode_type::REGULARIZE_MODE, IN in operating_mode_type::CONVEX_HULL_MODE.

      \warning    Upon exit, the matrix is resized to two rows. 
                  The third coordinate (Z) is lost for all points.
      */
   DoubleMat               pos;

   /**
      The hard edges (boundary edges + internal hard edges).

      This connectivity matrix must define a valid and closed edge mesh for the 
      external boundary of the domain.

      The orientation of these boundary edges should be similar (either all CW or all CCW), 
      except when:
         - There is only a single external contour.
         - operating_mode_type::subdomains_forcing = +1. 
           In this case, all subdomains are filled with elements (no hole).

      Internal (embedded) hard edges can be added to the boundary mesh. 

      In order to define holes inside the domain, the boundary mesh of the holes must be closed
      and oriented oppositely to the external boundary mesh (and operating_mode_type::subdomains_forcing = 0 or -1).

      The indices refer to columns in the coordinates matrix \ref pos.

      \note    When operating_mode_type::reset_external_boundaries_flag is \c true (or when \ref connectB is empty), 
               \ref connectB is automatically computed in the operating_mode_type::REGULARIZE_MODE 
               (by appending the edges belonging to only one face).
      \note    In operating_mode_type::CONVEX_HULL_MODE, the nodes in connectB are taken into account with the
               isolated nodes.

      Mode = IN in operating_mode_type::MESH_MODE and operating_mode_type::CONVEX_HULL_MODE, 
             IN-OUT in operating_mode_type::REGULARIZE_MODE.
      */
   UIntMat                 connectB;

   /**
      The internal (embedded) hard nodes.

      \note    The indices refer to columns in the coordinates matrix \ref pos.
      \note    Isolated nodes disable structured meshing.

      Mode = IN.
      */
   UIntVec                 isolated_nodes;

   /**
      The nodes of the mesh (that are not hard nodes) will be placed away from
      these repulsive points.

      \note    The indices refer to columns in the coordinates matrix \ref pos.
      \note    Repulsive points disable structured meshing (even if they are located outside of the domain).
      \note    Only repulsive points associated to a valid metric (i.e. positive value in
               vector \ref metrics) are taken into account.
      \note    Not used in operating_mode_type::CONVEX_HULL_MODE.

      Mode = IN.
      */
   UIntVec                 repulsive_points;

   /**
      The connectivity matrix of the background mesh, made of triangles (column oriented). 

      The indices of the nodes refer to columns in the coordinates matrix \ref pos.
      These indices must also refer to valid values in the \ref metrics array.

      The background mesh doesn't need to match exactly the domain to be meshed. 
      It is allowed to extend the domain or to cover only a fraction of it.
      For subdomains outside of the background mesh, the standard interpolation of the metrics
      defined (or computed) at the hard nodes is used.

      \warning    The use of a background mesh may slow down the generator significantly.
                  The finer the background mesh, the slower the meshing.

      Mode = IN in operating_mode_type::MESH_MODE and operating_mode_type::REGULARIZE_MODE.
      */
   UIntMat                 background_mesh;

   /**
      Element sizes specified at nodes.

      For nodes with invalid metric (missing, negative or null), an automatic size is 
      computed using the distances to their neighbors and stored in this vector upon exit.

      \note    Upon exit, this array takes into account the values operating_mode_type::target_metric 
               and operating_mode_type::max_gradation.
      \note    Not used in operating_mode_type::CONVEX_HULL_MODE.

      Mode = IN-OUT.
      */
   DoubleVec               metrics;

   /**
      The connectivity of the elements (column oriented). 

      The indices refer to columns in the coordinates matrix \ref pos.

      The dimensions of this matrix are 3 x \ref nefs.

      Mode = OUT in operating_mode_type::MESH_MODE and operating_mode_type::CONVEX_HULL_MODE, 
             IN-OUT in operating_mode_type::REGULARIZE_MODE.
      */
   UIntMat                 connectM;

   /**
      The boundaries that could not be enforced in the mesh.

      This vector gives the column IDs in the \ref connectB matrix that could not be enforced in
      the mesh (i.e. edges intersected by other hard nodes or hard edges, edges outside the domain).

      \note    In strict-constraint mode (operating_mode_type::strict_constraints_flag = \c true), 
               the generator stops with an error when this vector is not empty.
      \note    Used in operating_mode_type::MESH_MODE only.

      Mode = OUT.
      */
   UIntVec                 unenforced_boundary_IDs;        

   /**
      The nodes that could not be enforced in the mesh.

      This vector gives the indices of the nodes that could not be enforced in
      the final mesh (i.e. nodes coincident with another one, nodes inside hard edges, nodes outside the domain).

      \note    In strict-constraint mode (operating_mode_type::strict_constraints_flag = \c true), 
               the generator stops with an error when this vector contains nodes located inside the domain to be meshed
               (nodes outside do not stop the generator).
      \note    Used in operating_mode_type::MESH_MODE only.

      Mode = OUT.
      */
   UIntVec                 unenforced_node_IDs;        

   /**
      The boundaries that intersect other boundary(ies).

      This vector gives the column IDs in the \ref connectB matrix of the edges that intersect other hard edge(s).

      \note    In strict-constraint mode (operating_mode_type::strict_constraints_flag = \c true), 
               the generator stops with an error when this vector is not empty.
      \note    Used in operating_mode_type::MESH_MODE only.

      Mode = OUT.
      */
   UIntVec                 pathological_boundary_IDs;        

   /**
      The "color" of the elements. 

      Each subdomain is assigned with a color ID (starting from 1).
      Each element is assigned with the color ID of the subdomain it belongs to.

      A subdomain here means a domain's subset of connected elements (not separated by any boundary).
      Two elements are in the same subdomain when there is a element path between them which is not crossed by any boundary.
      
      Upon exit, the size of this vector equals to the number of elements in \ref connectM.

      The indices refer to columns in the connectivity matrix \ref connectM.

      In operating_mode_type::REGULARIZE_MODE, this vector is used only on entry.
      The user can also provide an empty color vector. In this case, all elements 
      are assumed to be in the same part (subdomain #1).

      Mode = OUT in operating_mode_type::MESH_MODE, IN-OUT in operating_mode_type::REGULARIZE_MODE.
      */
   UIntVec                 colors;

   /**
      The neighbors matrix. 

      \c neighbors(i,j) is the neighbor of element \c j with edge \c i.

      The dimensions of this matrix are 3 x \ref nefs.

      \see  The User's Manual.

      Mode = OUT.
      */ 
   UIntMat                 neighbors;

   /**
      The ancestors vector. 

      \c ancestors[i] is the index of one of the elements connected to node \c i.

      These indices refer to columns in matrices \ref connectM and \ref neighbors, and to position
      in vector \ref colors.

      If a point is not connected to any element, its ancestors'index equals to \c CM2_NONE (i.e. \c unsigned(-1)).

      The size of this vector equals to pos.cols() (i.e. number of points).

      Mode = OUT.
      */ 
   UIntVec                 ancestors;

   /**
      The shape qualities vector. 

      The size of this vector is \ref nefs.

      \see  The User's Manual.

      Mode = OUT.
      */ 
   DoubleVec               shape_qualities;

   /**
      The histogram of the element shape qualities.

      Mode = OUT.
      */ 
   cm2::misc::histogram    histo_Qs; 

   /**
      The histogram of the edges qualities (edge length).

      Computed only when operating_mode_type::compute_Qh_flag = true.

      Mode = OUT.
      */ 
   cm2::misc::histogram    histo_Qh;

   /**
      Number of elements in the final mesh. 

      Mode = OUT.
      */ 
   unsigned                nefs;

   /**
      Number of quads in the final mesh. Always null. 

      Provided for compatibility with quadmesh::mesher.

      Mode = OUT.
      */ 
   unsigned                nefs_Q4;

   /**
      Number of triangles in the final mesh. Same as \ref nefs.

      Provided for compatibility with quadmesh::mesher.

      Mode = OUT.
      */ 
   unsigned                nefs_T3;

   /**
      Number of nodes in the final mesh. 

      Mode = OUT.
      */ 
   unsigned                nods;

   /**
      Total number of points in the coordinates matrix.

      \post Greater or equal to \ref nods.
      \post Equal to ancestors.cols().
      \post Equal to metrics.size().

      Mode = OUT.
      */ 
   unsigned                total_nods;

   /**
      The number of initial hard nodes.

      Mode = OUT.
      */ 
   unsigned                hard_nodes_in;

   /**
      The number of initial hard edges. 

      Mode = OUT.
      */ 
   unsigned                hard_edges_in;

   /**
      The number of final hard nodes (lesser than or equal to \ref hard_nodes_in). 

      Mode = OUT.
      */ 
   unsigned                hard_nodes_out;

   /**
      The number of final hard edges (lesser than or equal to \ref hard_edges_in). 

      Mode = OUT.
      */ 
   unsigned                hard_edges_out;

   /**
      Area of the meshed domain (sum of the areas of all elements).

      Mode = OUT.
      */ 
   double                  area;

   /**
      Area of the quadrangles. Always null.

      Provided for compatibility with quadmesh::mesher.

      Mode = OUT.
      */ 
   double                  area_Q4;

   /**
      Area of the triangles. Same as \ref area.

      Provided for compatibility with quadmesh::mesher.

      Mode = OUT.
      */ 
   double                  area_T3;

   /**
      Minimum shape quality of the elements upon entry. 

      Mode = OUT in operating_mode_type::REGULARIZE_MODE only.
      */ 
   double                  Qmin_in;

   /**
      Minimum shape quality of the elements upon exit. 

      Mode = OUT.
      */ 
   double                  Qmin;

   /**
      The bounding box's min corner (lower-left). 

      Mode = OUT.
      */ 
   DoubleVec2              min_box;

   /**
      The bounding box's max corner (upper-right). 

      Mode = OUT.
      */ 
   DoubleVec2              max_box;

   /**
      Number of subdomains in the domain.

      Mode = OUT.
      */ 
   unsigned                subdomains;

   /**
      The orientation of the external contour.

      The orientation sign is defined by:
         -  +1 if oriented counter-clockwise.
         -  -1 if oriented clockwise.

      \note    If the external contour has not a well-defined orientation (i.e. some edges are CCW, some are CW),
               this output parameter is irrelevant (can be either +1 or -1).
               We recall here that, in this case, no internal closed contour should be added, nor any other 
               external contour (multiple disconnected subdomains). 
      \note    This parameter is computed in operating_mode_type::MESH_MODE only.

      Mode = OUT.
      */ 
   int                     boundary_sgn;

   /**
      Time spent for the initial front mesh. 

      Mode = OUT.
      */ 
   double                  front_time;

   /**
      Time spent for refining the mesh. 

      Mode = OUT.
      */ 
   double                  refine_time;

   /**
      Time spent for optimizing the mesh.

      Mode = OUT.
      */ 
   double                  optim_time;

   /**
      Total time spent for the mesh.

      Mode = OUT.
      */ 
   double                  total_time; 

   /**
      Number of elements per second. 
      Global speed including all steps of the meshing / optimizing process.

      Mode = OUT.
      */ 
   double                  speed;

   /**
      Error code. 

      Mode = OUT.
      */ 
   error_type              error_code;

   /**
      Warning code. 

      Mode = OUT.
      */ 
   warning_type            warning_code;

   /**
      Error/Warning message #1. 

      Mode = OUT.
      */ 
   char                    msg1[256];

   /**
      Error/Warning message #2.
      Debug purpose only.

      Mode = OUT.
      */ 
   char                    msg2[256];

   };    // data_type



/**
   Default constructor.

   The operating mode has the default settings.

   See \link cm2::triamesh::mesher::operating_mode_type::operating_mode_type() default sttings \endlink.
   */
mesher();

/**
   Constructor with a specific operating mode.

   \param[in]   mode_        The operating mode. 
   */
mesher (operating_mode_type mode_);

/**
   Is the %mesher authorized to run ?

   \see  triamesh::registration.
   */
static bool
authorized();

/**
   Main function of the %mesher.

   Depending of the operating mode in the \ref mode parameter, the %mesher can work
   as a regular %mesher or as a mesh optimizer.

   \param[in,out]   data   The data.
   */
void 
run (data_type& data) const;


/**
   The operating mode for the %mesher.

   See \link cm2::triamesh::mesher::operating_mode_type::operating_mode_type() default values \endlink.
   */
operating_mode_type        mode;

};

}  // end namespace triamesh


I've honestly no idea what to do. All the required files seem in place. I can find plenty of triamesh and quadmesh references and their respective header files and .dlls. What might be missing??? Can you tell by the code? Should I upload the solution?

Thanks again.
Was This Post Helpful? 0
  • +
  • -

#4 AmitTheInfinity  Icon User is offline

  • C Surfing ∞
  • member icon

Reputation: 119
  • View blog
  • Posts: 1,565
  • Joined: 25-January 07

Re: Unresolved external symbol

Posted 22 May 2014 - 05:04 AM

Not sure if it's a good idea to upload the solution as you are working on a project for some company (ethics). I would guess it's some messed up includes that's causing this. But it's difficult to confirm without code. Taking help from peers in such cases would be better idea.
Was This Post Helpful? 1
  • +
  • -

#5 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 05:32 AM

View PostAmitTheInfinity, on 22 May 2014 - 05:04 AM, said:

Not sure if it's a good idea to upload the solution as you are working on a project for some company (ethics). I would guess it's some messed up includes that's causing this. But it's difficult to confirm without code. Taking help from peers in such cases would be better idea.


Thanks a lot for your honesty and help :)

Problem is, I'm the only programmer in the company. It's a small company. Like a branch of the bigger version of a company that's in the US. Only the CEO knows how to put together some C++ and even he shows signs of not understanding it too good.

Here's what I'll do: I'll scan the whole code for references and includes where there might be a problem. I think It's noteworthy that the CEO was able to compile this before in his computer, though. All I can think might be wrong are paths.

Is there any way I can help you help me? I really want to stay in this company It's gonna open so many doors for my future and the only problem I've encountered so far was really just compiling this thing. I'd really appreciate if you could just keep giving me a few tips please. I'll do as I said and if I run into anything new I'll be sure to let everyone know.

Thanks again.
Was This Post Helpful? 0
  • +
  • -

#6 yashwanth.c.b  Icon User is offline

  • D.I.C Head

Reputation: 31
  • View blog
  • Posts: 234
  • Joined: 07-July 13

Re: Unresolved external symbol

Posted 22 May 2014 - 05:53 AM

Quote

I can find plenty of
triamesh and quadmesh references and their
respective header files and .dlls.

are you sure that .dll's are linked well...
Was This Post Helpful? 1
  • +
  • -

#7 Skydiver  Icon User is online

  • Code herder
  • member icon

Reputation: 5949
  • View blog
  • Posts: 20,394
  • Joined: 05-May 12

Re: Unresolved external symbol

Posted 22 May 2014 - 05:55 AM

You could call the company that makes that library:
http://www.computing...view/16/22/lang,en/

Based on the comments in the header, it looks like this the "registration" is part of their "copy protection" based on the header that you posted above.
/**
   Is the %mesher authorized to run ?

   \see  triamesh::registration.
   */
static bool
authorized();



Anyway, while waiting for a response from the company, I would double check that I am correctly linking in all their libraries. In your first post, all you mentioned was that you had setup paths, but you made no mention of adding libraries to your linker settings.
Was This Post Helpful? 1
  • +
  • -

#8 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 06:15 AM

View Postyashwanth.c.b, on 22 May 2014 - 05:53 AM, said:

Quote

I can find plenty of
triamesh and quadmesh references and their
respective header files and .dlls.

are you sure that .dll's are linked well...


Thing is, why can't I see the Linker tab? I've googled it but it doesn't seem to be a common problem, so I must be doing something stupidly wrong.

[spoiler]Posted Image[spoiler]



View PostSkydiver, on 22 May 2014 - 05:55 AM, said:

You could call the company that makes that library:
http://www.computing...view/16/22/lang,en/

Based on the comments in the header, it looks like this the "registration" is part of their "copy protection" based on the header that you posted above.
/**
   Is the %mesher authorized to run ?

   \see  triamesh::registration.
   */
static bool
authorized();



Anyway, while waiting for a response from the company, I would double check that I am correctly linking in all their libraries. In your first post, all you mentioned was that you had setup paths, but you made no mention of adding libraries to your linker settings.


That's where I downloaded the files, yes. I was provided with a setup file containing all the files I needed. I ran the setup again just in case. No new files were added, everything's as it was. Did I mention I compiled the first two projects I was tasked with compiling? They didn't require trimesh and quadmesh, though.

The registration is taken care of. I'm really sorry that I wasn't specific and detailed enough! The license keys are registered in main.cpp.

Yes I suspect the Linker settings might be the problem..how dense of me. You see, I can't seem to be able to access that property tab, as you can see in the screenshot above. I've tried "Project>Properties" in that screenshot. But I've also tried right-clicking the solution and properties. Not the same property menu.

Thanks a lot to everyone who's trying to help me. I understand to you this might come off as a trivial error and that I must be doing something stupid. Which I most likely am.
Was This Post Helpful? 0
  • +
  • -

#9 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 06:28 AM

You can't edit posts..?

Anyway it might be relevant to say these projects were made in VS2010 and I'm in 2012. When I opened the project file it asked me to update the files or something along those lines and I disagreed to do so. Thought messing with the files could cause me further problems.

Possible irony here.
Was This Post Helpful? 0
  • +
  • -

#10 yashwanth.c.b  Icon User is offline

  • D.I.C Head

Reputation: 31
  • View blog
  • Posts: 234
  • Joined: 07-July 13

Re: Unresolved external symbol

Posted 22 May 2014 - 07:05 AM

have u tried restarting the browser.....just a guess
Was This Post Helpful? 0
  • +
  • -

#11 JackOfAllTrades  Icon User is offline

  • Saucy!
  • member icon

Reputation: 6246
  • View blog
  • Posts: 24,014
  • Joined: 23-August 08

Re: Unresolved external symbol

Posted 22 May 2014 - 07:08 AM

Unresolved external symbols aren't due to missing includes, but to missing linked libraries, as Skydiver points out. Could also be you need to set paths to these libraries so that they are found by the linker.

I think you should retry importing the solution and allow the conversion to VS 2012. Make a copy of the files in a different directory if you're concerned about messing with the ones you have, then operate on the copy.

Or perhaps check them into your source code control system (you do have one, right?). That way if anything ends up destroying what you have, you can just start over with the fresh ones from the source code repository.
Was This Post Helpful? 1
  • +
  • -

#12 yashwanth.c.b  Icon User is offline

  • D.I.C Head

Reputation: 31
  • View blog
  • Posts: 234
  • Joined: 07-July 13

Re: Unresolved external symbol

Posted 22 May 2014 - 07:10 AM

Quote

When I opened the project file it asked me to
update the files

create a backup copy of your project files and try to update it.....
Was This Post Helpful? 0
  • +
  • -

#13 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 07:33 AM

So I opened the VCPROJ file instead of opening VCXPROJ this time, and I was asked to do a one-way upgrade. After the upgrade, which replaced my project file for a new one, I got this log:

Spoiler


After debugging thsi thing again, I got this error:

Error	6	error MSB4198: The expression "DirectoryName" cannot be evaluated on item ""..\..\..\libs\DebugWin32\tutorial02_Q4.exe"". Illegal characters in path.	C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V110\Microsoft.CppBuild.targets	1170	23	tutorial02_Q4



However, I can now see my Linker tab again, so I assume I'll be able to take care of that error without a problem. I'll update you guys as soon as anything new happens.

Thanks a million for all the help. This site is amazing, It's almost like you're being paid to aid me. (you should)
Was This Post Helpful? 0
  • +
  • -

#14 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 07:58 AM

View Postyashwanth.c.b, on 22 May 2014 - 07:05 AM, said:

have u tried restarting the browser.....just a guess


I did, just now. Same thing :/ Is it a common error?


Ok so, after changing the Linker path to a .manifest file (it was the closest thing to an .exe I could find?), I stopped getting that new error, and I'm back to the old ones.

However, after debugging again, the .manifest disappeared and I think I should be showing you the Output:

1>------ Build started: Project: tutorial02_Q4, Configuration: Debug Win32 ------
1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V110\Microsoft.CppBuild.targets(1137,5): warning MSB8012: TargetPath(C:\PROJECTOS\tutorials_fem\tutorial02_Q4\DebugWin32\tutorial02_Q4.exe) does not match the Linker's OutputFile property value (C:\PROJECTOS\tutorials_fem\tutorial02_Q4\DebugWin32\tutorial02_Q4.exe.intermediate.manifest). This may cause your project to build incorrectly. To correct this, please make sure that $(OutDir), $(TargetName) and $(TargetExt) property values match the value specified in %(Link.OutputFile).
1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V110\Microsoft.CppBuild.targets(1138,5): warning MSB8012: TargetExt(.exe) does not match the Linker's OutputFile property value (.manifest). This may cause your project to build incorrectly. To correct this, please make sure that $(OutDir), $(TargetName) and $(TargetExt) property values match the value specified in %(Link.OutputFile).
1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V110\Microsoft.CppBuild.targets(1139,5): warning MSB8012: TargetName(tutorial02_Q4) does not match the Linker's OutputFile property value (tutorial02_Q4.exe.intermediate). This may cause your project to build incorrectly. To correct this, please make sure that $(OutDir), $(TargetName) and $(TargetExt) property values match the value specified in %(Link.OutputFile).
1>main.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) void __cdecl cm2::triamesh::registration(char const *,char const *)" ([email protected]@[email protected]@[email protected]) referenced in function _main
1>main.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) void __cdecl cm2::quadmesh::registration(char const *,char const *)" ([email protected]@[email protected]@[email protected]) referenced in function _main
1>C:\PROJECTOS\tutorials_fem\tutorial02_Q4\DebugWin32\tutorial02_Q4.exe.intermediate.manifest : fatal error LNK1120: 2 unresolved externals
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========



If the .manifest hadn't disappeared, by now I'd be adapting all the other things to the new linker path I added. But since It's gone I assume I'm doing something wrong and so I must ask: How do I build the .exe file?

By now you must be thinking "Does this guy even know anything?". I worked with VS 2010 to code some C#, HTML, CSS, Javascript and VB. That's it. No C++. No tricky library linking. No compiling foreign code.

Posted Image
Was This Post Helpful? 0
  • +
  • -

#15 AuRuMuS  Icon User is offline

  • New D.I.C Head

Reputation: 1
  • View blog
  • Posts: 40
  • Joined: 22-May 14

Re: Unresolved external symbol

Posted 22 May 2014 - 09:42 AM

I'm sorry for triple-posting but I really need to update this and I swear there's no edit button.


So apparently I'm able to compile ("CTRL + F7") this without a problem, and I've compiled 3 other projects thus far. However if I am to try and actually debug it using Local Windows Debugger, it gets me the same error. Like in the 5th one I get this:

1>------ Build started: Project: tutorial03_Q4, Configuration: Debug Win32 ------
1>C:\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\V110\Microsoft.CppBuild.targets(1137,5): warning MSB8012: TargetPath(C:\PROJECTOS\tutorials_fem\tutorial03_Q4\DebugWin32\tutorial03_Q4.exe) does not match the Linker's OutputFile property value (C:\libs\DebugWin32\tutorial03_Q4.exe). This may cause your project to build incorrectly. To correct this, please make sure that $(OutDir), $(TargetName) and $(TargetExt) property values match the value specified in %(Link.OutputFile).
1>main.obj : error LNK2019: unresolved external symbol "__declspec(dllimport) void __cdecl cm2::triamesh::registration(char const *,char const *)" ([email protected]@[email protected]@[email protected]) referenced in function _main
1>..\..\..\libs\DebugWin32\tutorial03_Q4.exe : fatal error LNK1120: 1 unresolved externals
========== Build: 0 succeeded, 1 failed, 0 up-to-date, 0 skipped ==========



Apparently I'm not getting the same for quadmesh though...interesting. I didn't do anything to quadmesh.
Was This Post Helpful? 0
  • +
  • -

  • (5 Pages)
  • +
  • 1
  • 2
  • 3
  • Last »