我尝试在Eclipse上使用C语言使用LIBSVM来执行二进制类machine learning（仅两个类）。在开始使用训练数据之前，我尝试运行一个简单的XOR问题，看看我的LIBSVM应用程序是否可以预测正确的输出值（假定为+1）。
但是，在我构建项目之后，我遇到了一些错误，例如 * 未定义对'_Heap_Begin'的引用 、 未定义对'_Heap_Limit'的引用 * 和 * 未定义对'__reset_hardware'的引用 *。
我将 svm.h 文件添加到了“include”文件夹中，将 svm_train.c 和 svm.cpp 文件添加到了“src”文件夹中，并且已经在源文件中执行了#include 'svm.h'，这是我在LIBSVM中遵循的 README 文件中的说明。我遵循了README文件中的所有说明，其中声明 “您需要在C/C++源文件中#include“svm.h”，并将程序与“svm. cpp”链接。"
我做错了什么？

文件 svm.h

#ifndef _LIBSVM_H
#define _LIBSVM_H

#define LIBSVM_VERSION 322

#ifdef __cplusplus
extern "C" {
#endif

extern int libsvm_version;

struct svm_node
{
    int index;
    double value;
};

struct svm_problem
{
    int l;
    double *y;
    struct svm_node **x;
};

enum { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR }; /* svm_type */
enum { LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED };  /* kernel_type */

struct svm_parameter
{
    int svm_type;
    int kernel_type;
    int degree;    /* For poly */
    double gamma;  /* For poly/rbf/sigmoid */
    double coef0;  /* For poly/sigmoid */

    /* These are for training only */
    double cache_size; /* In MB */
    double eps;        /* Stopping criteria */
    double C;          /* For C_SVC, EPSILON_SVR and NU_SVR */
    int nr_weight;     /* For C_SVC */
    int *weight_label; /* For C_SVC */
    double* weight;    /* For C_SVC */
    double nu;         /* For NU_SVC, ONE_CLASS, and NU_SVR */
    double p;          /* For EPSILON_SVR */
    int shrinking;     /* Use the shrinking heuristics */
    int probability;   /* Do probability estimates */
};

//
// svm_model
//
struct svm_model
{
    struct svm_parameter param;  /* Parameter */
    int nr_class;                /* Number of classes, = 2 in regression/one class svm */
    int l;                       /* Total #SV */
    struct svm_node **SV;        /* SVs (SV[l]) */
    double **sv_coef;            /* Coefficients for SVs in decision functions (sv_coef[k-1][l]) */
    double *rho;                 /* Constants in decision functions (rho[k*(k-1)/2]) */
    double *probA;               /* Pariwise probability information */
    double *probB;
    int *sv_indices;             /* sv_indices[0, ..., nSV-1] are values in [1, ..., num_traning_data] to indicate SVs in the training set */

    /* For classification only */

    int *label;  /* Label of each class (label[k]) */
    int *nSV;    /* Number of SVs for each class (nSV[k]) */
                 /* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
    /* XXX */
    int free_sv; /* 1 if svm_model is created by svm_load_model*/
                 /* 0 if svm_model is created by svm_train */
};

struct svm_model *svm_train(const struct svm_problem *prob, const struct svm_parameter *param);
void svm_cross_validation(const struct svm_problem *prob, const struct svm_parameter *param, int nr_fold, double *target);

int svm_save_model(const char *model_file_name, const struct svm_model *model);
struct svm_model *svm_load_model(const char *model_file_name);

int svm_get_svm_type(const struct svm_model *model);
int svm_get_nr_class(const struct svm_model *model);
void svm_get_labels(const struct svm_model *model, int *label);
void svm_get_sv_indices(const struct svm_model *model, int *sv_indices);
int svm_get_nr_sv(const struct svm_model *model);
double svm_get_svr_probability(const struct svm_model *model);

double svm_predict_values(const struct svm_model *model, const struct svm_node *x, double* dec_values);
double svm_predict(const struct svm_model *model, const struct svm_node *x);
double svm_predict_probability(const struct svm_model *model, const struct svm_node *x, double* prob_estimates);

void svm_free_model_content(struct svm_model *model_ptr);
void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);
void svm_destroy_param(struct svm_parameter *param);

const char *svm_check_parameter(const struct svm_problem *prob, const struct svm_parameter *param);
int svm_check_probability_model(const struct svm_model *model);

void svm_set_print_string_function(void (*print_func)(const char *));

#ifdef __cplusplus
}
#endif

#endif /* _LIBSVM_H */

文件 svm_train.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>
#include "svm.h"

#define Malloc(type,n) (type *)malloc((n)*sizeof(type))

struct svm_parameter param;     // Set by parse_command_line
struct svm_problem prob;        // Set by read_problem
struct svm_model *model;
struct svm_node *x_space;
struct svm_node ** x;
struct svm_node *testnode;

void main(void)
{
    param.svm_type = C_SVC;
    param.kernel_type = RBF;
    param.degree = 3;
    param.gamma = 0.5;
    param.coef0 = 0;
    param.nu = 0.5;
    param.cache_size = 100;
    param.C = 1;
    param.eps = 1e-3;
    param.p = 0.1;
    param.shrinking = 1;
    param.probability = 0;
    param.nr_weight = 0;
    param.weight_label = NULL;
    param.weight = NULL;

    // Problem definition-------------------------------------------------------------
    prob.l = 4;

    // x values matrix of xor values (training data)
    double matrix[prob.l][2];
    matrix[0][0] = 1;
    matrix[0][1] = 1;

    matrix[1][0] = 1;
    matrix[1][1] = 0;

    matrix[2][0] = 0;
    matrix[2][1] = 1;

    matrix[3][0] = 0;
    matrix[3][1] = 0;

    // This part i do not understand
    struct svm_node** x = (struct svm_node * *)malloc((prob.l)*sizeof(struct svm_node *));

    // Trying to assign from matrix to svm_node training examples
    for (int row = 0; row <prob.l; row++)
    {
        struct svm_node* x_space = Malloc(struct svm_node, 3);
        for (int col = 0; col < 2; col++)
        {
            x_space[col].index = col;
            x_space[col].value = matrix[row][col];
        }
        x_space[2].index = -1;  // Each row of properties should be terminated with a -1 according to the readme
        x[row] = x_space;
    }

    prob.x = x;

    // Y values
    prob.y = (double *)malloc((prob.l)*sizeof(double));
    prob.y[0] = -1;
    prob.y[1] = 1;
    prob.y[2] = 1;
    prob.y[3] = -1;

    // Train model---------------------------------------------------------------------
    struct svm_model *model = svm_train(&prob, &param);

    // Test model----------------------------------------------------------------------
    struct svm_node* testnode = (struct svm_node *) malloc((3)*sizeof(struct svm_node));
    testnode[0].index = 0;
    testnode[0].value = 1;
    testnode[1].index = 1;
    testnode[1].value = 0;
    testnode[2].index = -1;

    double retval = svm_predict(model, testnode);

    svm_destroy_param(&param);
    free(prob.y);
    free(prob.x);
    free(x_space);
}