C++ C++；OSX上的Boost类型下标运算符错误

我希望能够在OSX上工作，尽管我已经安装了所有必需的依赖项，但运行make命令会被以下几个错误打断：

/SMTPlan/include/SMTPlan/EncoderHappening.h:155:51: error: type
      'boost::container::flat_set<std::__1::basic_string<char>, std::__1::less<std::__1::basic_string<char> >, void>' does not provide
      a subscript operator

        int fID = algebraist->function_id_map[args[i].get_name()];

/SMTPlan/include/SMTPlan/EncoderHappening.h:155:51:错误：类型
“boost:：container:：flat_set”未提供
下标运算符
int fID=algebrast->function_id_map[args[i].get_name（）；

考虑到我没有更改源代码，也没有安装所有依赖项，我不明白为什么会发生这种情况。我记得在OSX上clingo错误地编译C代码时遇到了一些问题，尽管它在Ubuntu上运行，所以可能又发生了这种情况？我认为部分问题在于编译器错误地猜测了变量的类型，但这只发生在OSX上。我仍然在学习C++，所以任何帮助都将非常感谢。我已经复制了下面EncoderHappening.h的源代码，如果需要，可以提供更多的代码摘录

#include <sstream>
#include <string>
#include <cstdio>
#include <iostream>
#include <vector>

#include "z3++.h"

#include "ptree.h"
#include "instantiation.h"
#include "VisitController.h"
#include "FastEnvironment.h"
#include "TIM.h"

#include "SMTPlan/Encoder.h"
#include "SMTPlan/PlannerOptions.h"
#include "SMTPlan/ProblemInfo.h"
#include "SMTPlan/Algebraist.h"

#ifndef KCL_encoder_happening
#define KCL_encoder_happening

namespace SMTPlan
{
    class EncoderHappening : public Encoder
    {
    private:

        /* encoding info */
        int upper_bound;
        int next_layer;
        std::vector<z3::expr> goal_expression;

        /* problem info */
        PlannerOptions * opt;
        ProblemInfo * problem_info;
        VAL::FastEnvironment * fe;
        VAL::analysis * val_analysis;
        Algebraist * algebraist;

        /* encoding state */
        int enc_litID;
        int enc_pneID;
        int enc_opID;
        int enc_tilID;
        std::string enc_op_string;

        bool enc_continuous;
        bool enc_cond_neg;
        bool enc_eff_neg;
        bool enc_make_op_vars;

        VAL::time_spec enc_cond_time;
        VAL::time_spec enc_eff_time;
        VAL::comparison_op enc_comparison_op;

        /* more encoding state */
        EncState enc_state;
        int enc_expression_h;
        int enc_expression_b;
        std::vector<z3::expr> enc_expression_stack;

        std::vector<z3::expr> enc_musts_expression_stack;
        std::vector<z3::expr> enc_musts_discrete_stack;

        z3::expr_vector* enc_event_condition_stack;

        std::string enc_function_symbol;

        /* encoding information */
        std::vector<std::vector<int> > simpleEventAddEffects;
        std::vector<std::vector<int> > simpleEventDelEffects;
        std::vector<std::vector<int> > simpleStartAddEffects;
        std::vector<std::vector<int> > simpleStartDelEffects;
        std::vector<std::vector<int> > simpleEndAddEffects;
        std::vector<std::vector<int> > simpleEndDelEffects;
        std::vector<std::vector<int> > simpleTILAddEffects;
        std::vector<std::vector<int> > simpleTILDelEffects;
        std::map<int, std::vector<std::pair<int, z3::expr> > > simpleEventAssignEffects;
        std::map<int, std::vector<std::pair<int, z3::expr> > > simpleStartAssignEffects;
        std::map<int, std::vector<std::pair<int, z3::expr> > > simpleEndAssignEffects;
        std::map<int, std::vector<std::pair<int, z3::expr> > > simpleTILAssignEffects;
        std::vector<bool> initialState;
        std::vector<int> action_ids;


        /* SMT variables */
        std::vector<z3::expr> time_vars;
        std::vector<z3::expr> duration_vars;
        std::vector<std::vector<std::vector<z3::expr> > > event_cascade_function_vars;
        std::vector<std::vector<std::vector<z3::expr> > > event_cascade_literal_vars;
        std::map<int, std::vector<std::vector<z3::expr>>> event_vars;
        std::map<int, std::vector<z3::expr> > sta_action_vars;
        std::map<int, std::vector<z3::expr> > end_action_vars;
        std::map<int, std::vector<z3::expr> > dur_action_vars;
        std::map<int, std::vector<z3::expr> > run_action_vars;
        std::map<int, std::vector<z3::expr> > til_vars;

        /* encoding methods */
        void encodeHeader(int H);
        void encodeTimings(int H);
        void encodeLiteralVariableSupport(int H);
        void encodeFunctionVariableSupport(int H);
        void encodeFunctionFlows(int H);
        void encodeGoalState(int H);
        void encodeInitialState();

        void parseExpression(VAL::expression * e);

        /* internal encoding methods */
        z3::expr mk_or(z3::expr_vector args) {
            std::vector<Z3_ast> array;
            for (unsigned i = 0; i < args.size(); i++) array.push_back(args[i]);
            return z3::to_expr(args.ctx(), Z3_mk_or(args.ctx(), array.size(), &(array[0])));
        }

        z3::expr mk_and(z3::expr_vector args) {
            std::vector<Z3_ast> array;
            for (unsigned i = 0; i < args.size(); i++) array.push_back(args[i]);
            return z3::to_expr(args.ctx(), Z3_mk_and(args.ctx(), array.size(), &(array[0])));
        }

        z3::expr mk_expr(pexpr poly, int h, int b) {

            auto it = poly._container().begin();
            auto end = poly._container().end();
            auto args = poly.get_symbol_set();

            z3::expr flow = z3_context->real_val(0);
            for (; it != end;) {

                // rational coefficient of term
                std::stringstream ss;
                ss << it->m_cf;
                z3::expr coeff = z3_context->real_val(ss.str().c_str());

                // symbols
                for (int i = 0; i < it->m_key.size(); i++) {
                    if (it->m_key[i] != pexpr(0)) {
                        // default symbol: #t
                        z3::expr sym = duration_vars[h];
                        if(args[i].get_name() != "hasht") {
                            if(algebraist->function_id_map.find(args[i].get_name()) == algebraist->function_id_map.end()) {
                                // symbol: real value
                                sym = z3_context->real_val(args[i].get_name().c_str());
                            } else {
                                // symbol: function name
                                int fID = algebraist->function_id_map[args[i].get_name()];
                                if(problem_info->staticFunctionMap[algebraist->predicate_head_map[fID]]) {
                                    sym = problem_info->staticFunctionValues.find(fID)->second;
                                } else {
                                    sym = event_cascade_function_vars[fID][h][b];
                                }
                            }
                        }
                        z3::expr arg = sym;
                        if (it->m_key[i] != pexpr(1))
                            arg = z3::pw(arg, it->m_key[i]);
                        coeff = (coeff * arg);
                    }
                }
                ++it;
                flow = (flow + coeff);
            }
            return flow;
        }

    public:

        EncoderHappening(Algebraist * alg, VAL::analysis* analysis, PlannerOptions &options, ProblemInfo &pi)
        {
            next_layer = 0;

            opt = &options;
            problem_info = &pi;
            val_analysis = analysis;
            algebraist = alg;

            enc_continuous = enc_cond_neg = enc_eff_neg = false;

            const int pneCount = Inst::instantiatedOp::howManyPNEs();
            const int litCount = Inst::instantiatedOp::howManyLiterals();

            simpleStartAddEffects = std::vector<std::vector<int> >(litCount);
            simpleStartDelEffects = std::vector<std::vector<int> >(litCount);
            simpleEventAddEffects = std::vector<std::vector<int> >(litCount);
            simpleEventDelEffects = std::vector<std::vector<int> >(litCount);
            simpleEndAddEffects = std::vector<std::vector<int> >(litCount);
            simpleEndDelEffects = std::vector<std::vector<int> >(litCount);
            simpleTILAddEffects = std::vector<std::vector<int> >(litCount);
            simpleTILDelEffects = std::vector<std::vector<int> >(litCount);

            initialState = std::vector<bool>(litCount);

            // for each [func|lit] : for each happening : for each cascade level
            event_cascade_function_vars = std::vector<std::vector<std::vector<z3::expr> > >(pneCount);
            event_cascade_literal_vars = std::vector<std::vector<std::vector<z3::expr> > >(litCount);

            z3::config cfg;
            cfg.set("auto_config", true);
            z3_context = new z3::context(cfg);
            z3_tactic = new z3::tactic(*z3_context, "qfnra-nlsat");
            z3_solver = new z3::solver(*z3_context, z3_tactic->mk_solver());
        }

        /* encoding methods */
        bool encode(int H);

        /*
         * add goal expression to the model for printing.
         * Usually the goal expression is only passed to the solver for checking.
         */
        void addGoal() {
            std::vector<z3::expr>::iterator git = goal_expression.begin();
            for(; git != goal_expression.end(); git++) 
                z3_solver->add(*git);
        };

        /* visitor methods */
        virtual void visit_action(VAL::action * o);
        virtual void visit_durative_action(VAL::durative_action * da);

        virtual void visit_simple_goal(VAL::simple_goal *);
        virtual void visit_qfied_goal(VAL::qfied_goal *);
        virtual void visit_conj_goal(VAL::conj_goal *);
        virtual void visit_disj_goal(VAL::disj_goal *);
        virtual void visit_timed_goal(VAL::timed_goal *);
        virtual void visit_imply_goal(VAL::imply_goal *);
        virtual void visit_neg_goal(VAL::neg_goal *);

        virtual void visit_assignment(VAL::assignment * e);
        virtual void visit_simple_effect(VAL::simple_effect * e);
        virtual void visit_forall_effect(VAL::forall_effect * e);
        virtual void visit_cond_effect(VAL::cond_effect * e);
        virtual void visit_timed_effect(VAL::timed_effect * e);
        virtual void visit_timed_initial_literal(VAL::timed_initial_literal * til);
        virtual void visit_effect_lists(VAL::effect_lists * e);

        virtual void visit_comparison(VAL::comparison *);
        virtual void visit_plus_expression(VAL::plus_expression * s);
        virtual void visit_minus_expression(VAL::minus_expression * s);
        virtual void visit_mul_expression(VAL::mul_expression * s);
        virtual void visit_div_expression(VAL::div_expression * s);
        virtual void visit_uminus_expression(VAL::uminus_expression * s);
        virtual void visit_int_expression(VAL::int_expression * s);
        virtual void visit_float_expression(VAL::float_expression * s);
        virtual void visit_special_val_expr(VAL::special_val_expr * s);
        virtual void visit_func_term(VAL::func_term * s);

        virtual void visit_preference(VAL::preference *);
        virtual void visit_event(VAL::event * e);
        virtual void visit_process(VAL::process * p);
        virtual void visit_derivation_rule(VAL::derivation_rule * o);

        /* solving */
//      z3::context * z3_context;
//      z3::tactic * z3_tactic;
//      z3::solver * z3_solver;
        z3::check_result solve();
        void printModel();
    };

} // close namespace

#endif

#包括
#包括
#包括
#包括
#包括
#包括“z3++.h”
#包括“ptree.h”
#包括“instantiation.h”
#包括“VisitController.h”
#包括“FastEnvironment.h”
#包括“TIM.h”
#包括“SMTPlan/Encoder.h”
#包括“SMTPlan/PlannerOptions.h”
#包括“SMTPlan/ProblemInfo.h”
#包括“SMTPlan/T.h”
#如果发生KCL\u编码器故障
#定义KCL_编码器_
名称空间SMTPlan
{
类编码器外观：公共编码器
{
私人：
/*编码信息*/
int上界；
int下一层；
std：：矢量目标函数表达式；
/*问题信息*/
计划者选项*opt；
ProblemInfo*问题信息；
VAL:：FastEnvironment*fe；
VAL:：analysis*VAL\u分析；
阿尔吉斯特*阿尔吉斯特；
/*编码状态*/
国际附件；
国际恩库普奈德；
国际专家组；
内部附件；
std:：字符串enc_op_字符串；
bool-enc_连续；
bool enc_cond_neg；
bool enc_eff_neg；
bool enc_make_op_vars；
VAL：：时间规格和秒时间；
VAL：：时间规格有效时间；
VAL：：比较_openc _comparison _op；
/*更多编码状态*/
enc_州enc_州；
int enc_表达式；
int enc_表达式_b；
std：：向量enc_表达式_堆栈；
std：：向量enc_must_表达式_堆栈；
std：：向量enc_必须离散_堆栈；
z3:：expr\u vector*enc\u event\u condition\u stack；
std:：字符串enc_函数_符号；
/*编码信息*/
std：：载体简单事件缺陷；
std：：向量simpleEventDelEffects；
std：：向量simpleStartAddEffects；
std：：向量simpleStartDelEffects；
std：：向量简单缺陷；
std：：向量简单缺陷；
std：：向量简单缺陷；
std：：向量单体效应；
std：：映射SimpleEventsSignEffects；
std:：map simplestatassigneffects；
std：：映射simpleEndAssignEffects；
映射SimpleClassSignEffects；
std：：向量初始状态；
std：：向量动作id；
/*SMT变量*/
std：：向量时间变量；
std：：向量持续时间变量；
std:：向量事件\级联\函数\变量；
std：：向量事件\级联\文本\变量；
映射事件变量；
标准：：地图状态和行动变量；
std：：映射结束动作变量；
std：：在行动中映射变量；
标准：：映射运行动作变量；
std：：映射til_vars；
/*编码方法*/
空编码头（inth）；
无效编码时间（inth）；
无效编码可变支持（inth）；
无效的可变支持（inth）；
无效流量（int H）；
目标状态（int H）；
void encodeInitialState（）；
void parseExpression（VAL:：expression*e）；
/*内部编码方法*/
z3:：expr mk_或（z3:：expr_向量参数）{
std：：矢量阵列；
对于（无符号i=0；ireal\u val（0）；
因为（；it！=end；）{
//有理项系数
std：：stringstream-ss；
ss m_cf；
z3:：expr coeff=z3_context->real_val（ss.str（）.c_str（））；
//象征
对于（int i=0；im_key.size（）；i++）{
如果（it->m_键[i]！=pexpr（0））{
//默认符号：#t
z3:：expr sym=持续时间_vars[h]；
if（args[i].get_name（）！=“hasht”）{
if（algebrist->function\u id\u map.find（args[i].get\u name（））==algebrist->function\u id\u map.end（））{
//符号：实际值
sym=z3_context->real_val（args[i].get_name（）.c_str（））；
}否则{
//符号：函数名
int fID=algebrast->function_id_map[args[i].get_name（）；
如果（问题信息->静态函数映射[Algebrast->谓词头映射[fID]]）{
sym=问题信息->静态函数值。查找（fID）->秒；
}否则{