Error C2259: cannot instantiate abstract class

@mumr · Регистрация: 09.03.2017

Author24 — интернет-сервис помощи студентам

Всем добрый день.
Создаю класс-наследник, переопределяю все виртуальные функции, но все равно ошибка "error C2259: cannot instantiate abstract class"
Мои предположения:
1. Мне из всех функций родителя нужна парочка, поэтому остальные переопределяю абы-как. Может быть здесь собака порылась?
2. Родительский класс сам по себе тоже наследник абстрактного класса, и в родителе функции родителя родителя почему-то не переопределены, тем не менее другие классы наследники родителя работают абсолютно нормально. в общем,буду благодарен, если объясните что к чему.
Код ниже, реализации наверное вставлять не буду, а то и так громоздко выходит, для примера постну одну свою:
Мой класс:

C++

class PathValueNode : public TypedNode<ValueExprNode, ExprNode::TYPE_PATH>
{
public:
    explicit PathValueNode(MemoryPool& pool);
 
    static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, const UCHAR blrOp);
    virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
    virtual Firebird::string internalPrint(NodePrinter& printer) const;
    virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
    virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
        const dsc* desc, bool forceVarChar)
    {
        return false;
    }
 
    virtual void setParameterName(dsql_par* parameter) const;
    virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
 
    virtual ValueExprNode* dsqlFieldRemapper(FieldRemapper& visitor)
    {
        ExprNode::dsqlFieldRemapper(visitor);
        return this;
    }
 
    virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb)
    {
        ExprNode::pass1(tdbb, csb);
        return this;
    }
 
    virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb)
    {
        ExprNode::pass2(tdbb, csb);
        return this;
    }
 
    virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
    virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
    virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
 
public:
    Firebird::Array<NestConst<PathNode>> path;
}; 
 
Реализация метода для примера:
 
DmlNode* PathValueNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, const UCHAR blrOp)
{
    return NULL;
}
 
Родительский класс:
class ValueExprNode : public ExprNode
{
public:
    ValueExprNode(Type aType, MemoryPool& pool)
        : ExprNode(aType, pool, KIND_VALUE),
          nodScale(0)
    {
        nodDesc.clear();
    }
 
public:
    virtual Firebird::string internalPrint(NodePrinter& printer) const = 0;
 
    virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch)
    {
        ExprNode::dsqlPass(dsqlScratch);
        return this;
    }
 
    virtual bool setParameterType(DsqlCompilerScratch* /*dsqlScratch*/,
        const dsc* /*desc*/, bool /*forceVarChar*/)
    {
        return false;
    }
 
    virtual void setParameterName(dsql_par* parameter) const = 0;
    virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc) = 0;
 
    virtual ValueExprNode* dsqlFieldRemapper(FieldRemapper& visitor)
    {
        ExprNode::dsqlFieldRemapper(visitor);
        return this;
    }
 
    virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb)
    {
        ExprNode::pass1(tdbb, csb);
        return this;
    }
 
    virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb)
    {
        ExprNode::pass2(tdbb, csb);
        return this;
    }
 
    // Compute descriptor for value expression.
    virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc) = 0;
 
    virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const = 0;
    virtual dsc* execute(thread_db* tdbb, jrd_req* request) const = 0;
 
public:
    SCHAR nodScale;
    dsc nodDesc;
};
 
Родитель родителя:
class ExprNode : public DmlNode
{
public:
    enum Type
    {
        // Value types
        TYPE_AGGREGATE,
        TYPE_ALIAS,
        TYPE_ARITHMETIC,
        TYPE_ARRAY,
        TYPE_BOOL_AS_VALUE,
        TYPE_CAST,
        TYPE_COALESCE,
        TYPE_COLLATE,
        TYPE_CONCATENATE,
        TYPE_CURRENT_DATE,
        TYPE_CURRENT_TIME,
        TYPE_CURRENT_TIMESTAMP,
        TYPE_CURRENT_ROLE,
        TYPE_CURRENT_USER,
        TYPE_DERIVED_EXPR,
        TYPE_DECODE,
        TYPE_DERIVED_FIELD,
        TYPE_DOMAIN_VALIDATION,
        TYPE_EXTRACT,
        TYPE_FIELD,
        TYPE_GEN_ID,
        TYPE_INTERNAL_INFO,
        TYPE_LITERAL,
        TYPE_MAP,
        TYPE_NEGATE,
        TYPE_NULL,
        TYPE_ORDER,
        TYPE_OVER,
        TYPE_PARAMETER,
        TYPE_RECORD_KEY,
        TYPE_SCALAR,
        TYPE_STMT_EXPR,
        TYPE_STR_CASE,
        TYPE_STR_LEN,
        TYPE_SUBQUERY,
        TYPE_SUBSTRING,
        TYPE_SUBSTRING_SIMILAR,
        TYPE_SYSFUNC_CALL,
        TYPE_TRIM,
        TYPE_UDF_CALL,
        TYPE_VALUE_IF,
        TYPE_VARIABLE,
 
        // Bool types
        TYPE_BINARY_BOOL,
        TYPE_COMPARATIVE_BOOL,
        TYPE_MISSING_BOOL,
        TYPE_NOT_BOOL,
        TYPE_RSE_BOOL,
 
        // RecordSource types
        TYPE_AGGREGATE_SOURCE,
        TYPE_PROCEDURE,
        TYPE_RELATION,
        TYPE_RSE,
        TYPE_SELECT_EXPR,
        TYPE_UNION,
        TYPE_WINDOW,
 
        // List types
        TYPE_REC_SOURCE_LIST,
        TYPE_VALUE_LIST
#ifdef _RxO
        , TYPE_CLASS,
        TYPE_PATH
#endif
    };
 
    // Generic flags.
    static const unsigned FLAG_INVARIANT    = 0x01; // Node is recognized as being invariant.
 
    // Boolean flags.
    static const unsigned FLAG_DEOPTIMIZE   = 0x02; // Boolean which requires deoptimization.
    static const unsigned FLAG_RESIDUAL     = 0x04; // Boolean which must remain residual.
    static const unsigned FLAG_ANSI_NOT     = 0x08; // ANY/ALL predicate is prefixed with a NOT one.
 
    // Value flags.
    static const unsigned FLAG_DOUBLE       = 0x10;
    static const unsigned FLAG_DATE         = 0x20;
    static const unsigned FLAG_VALUE        = 0x40; // Full value area required in impure space.
 
    explicit ExprNode(Type aType, MemoryPool& pool, Kind aKind)
        : DmlNode(pool, aKind),
          type(aType),
          nodFlags(0),
          impureOffset(0),
          dsqlCompatDialectVerb(NULL),
          dsqlChildNodes(pool),
          jrdChildNodes(pool)
    {
    }
 
    template <typename T> T* as()
    {
        const ExprNode* const thisPointer = this;   // avoid warning
        return thisPointer && type == T::TYPE ? static_cast<T*>(this) : NULL;
    }
 
    template <typename T> const T* as() const
    {
        const ExprNode* const thisPointer = this;   // avoid warning
        return thisPointer && type == T::TYPE ? static_cast<const T*>(this) : NULL;
    }
 
    template <typename T> bool is() const
    {
        const ExprNode* const thisPointer = this;   // avoid warning
        return thisPointer && type == T::TYPE;
    }
 
    template <typename T, typename LegacyType> static T* as(LegacyType* node)
    {
        return node ? node->template as<T>() : NULL;
    }
 
    template <typename T, typename LegacyType> static const T* as(const LegacyType* node)
    {
        return node ? node->template as<T>() : NULL;
    }
 
    template <typename T, typename LegacyType> static bool is(const LegacyType* node)
    {
        return node ? node->template is<T>() : false;
    }
 
    // Allocate and assign impure space for various nodes.
    template <typename T> static void doPass2(thread_db* tdbb, CompilerScratch* csb, T** node)
    {
        if (!*node)
            return;
 
        *node = (*node)->pass2(tdbb, csb);
    }
 
    virtual Firebird::string internalPrint(NodePrinter& printer) const = 0;
 
    virtual bool dsqlAggregateFinder(AggregateFinder& visitor)
    {
        bool ret = false;
 
        for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
            ret |= visitor.visit((*i)->getExpr());
 
        return ret;
    }
 
    virtual bool dsqlAggregate2Finder(Aggregate2Finder& visitor)
    {
        bool ret = false;
 
        for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
            ret |= visitor.visit((*i)->getExpr());
 
        return ret;
    }
 
    virtual bool dsqlFieldFinder(FieldFinder& visitor)
    {
        bool ret = false;
 
        for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
            ret |= visitor.visit((*i)->getExpr());
 
        return ret;
    }
 
    virtual bool dsqlInvalidReferenceFinder(InvalidReferenceFinder& visitor)
    {
        bool ret = false;
 
        for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
            ret |= visitor.visit((*i)->getExpr());
 
        return ret;
    }
 
    virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor)
    {
        bool ret = false;
 
        for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
            ret |= visitor.visit((*i)->getExpr());
 
        return ret;
    }
 
    virtual ExprNode* dsqlFieldRemapper(FieldRemapper& visitor)
    {
        for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
            (*i)->remap(visitor);
 
        return this;
    }
 
    template <typename T>
    static void doDsqlFieldRemapper(FieldRemapper& visitor, NestConst<T>& node)
    {
        if (node)
            node = node->dsqlFieldRemapper(visitor);
    }
 
    template <typename T1, typename T2>
    static void doDsqlFieldRemapper(FieldRemapper& visitor, NestConst<T1>& target, NestConst<T2> node)
    {
        target = node ? node->dsqlFieldRemapper(visitor) : NULL;
    }
 
    // Check if expression could return NULL or expression can turn NULL into a true/false.
    virtual bool possiblyUnknown()
    {
        for (NodeRef** i = jrdChildNodes.begin(); i != jrdChildNodes.end(); ++i)
        {
            if (**i && (*i)->getExpr()->possiblyUnknown())
                return true;
        }
 
        return false;
    }
 
    // Verify if this node is allowed in an unmapped boolean.
    virtual bool unmappable(const MapNode* mapNode, StreamType shellStream)
    {
        for (NodeRef** i = jrdChildNodes.begin(); i != jrdChildNodes.end(); ++i)
        {
            if (**i && !(*i)->getExpr()->unmappable(mapNode, shellStream))
                return false;
        }
 
        return true;
    }
 
    // Return all streams referenced by the expression.
    virtual void collectStreams(SortedStreamList& streamList) const
    {
        for (const NodeRef* const* i = jrdChildNodes.begin(); i != jrdChildNodes.end(); ++i)
        {
            if (**i)
                (*i)->getExpr()->collectStreams(streamList);
        }
    }
 
    virtual bool findStream(StreamType stream)
    {
        SortedStreamList streams;
        collectStreams(streams);
 
        return streams.exist(stream);
    }
 
    virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
 
    virtual ExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch)
    {
        DmlNode::dsqlPass(dsqlScratch);
        return this;
    }
 
    // Determine if two expression trees are the same.
    virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
 
    // See if node is presently computable.
    // A node is said to be computable, if all the streams involved
    // in that node are csb_active. The csb_active flag defines
    // all the streams available in the current scope of the query.
    virtual bool computable(CompilerScratch* csb, StreamType stream,
        bool allowOnlyCurrentStream, ValueExprNode* value = NULL);
 
    virtual void findDependentFromStreams(const OptimizerRetrieval* optRet,
        SortedStreamList* streamList);
    virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
    virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
    virtual ExprNode* copy(thread_db* tdbb, NodeCopier& copier) const = 0;
 
protected:
    template <typename T1, typename T2>
    void addChildNode(NestConst<T1>& dsqlNode, NestConst<T2>& jrdNode)
    {
        addDsqlChildNode(dsqlNode);
        addChildNode(jrdNode);
    }
 
    template <typename T>
    void addDsqlChildNode(NestConst<T>& dsqlNode)
    {
        dsqlChildNodes.add(FB_NEW_POOL(getPool()) NodeRefImpl<T>(dsqlNode.getAddress()));
    }
 
    template <typename T>
    void addChildNode(NestConst<T>& jrdNode)
    {
        jrdChildNodes.add(FB_NEW_POOL(getPool()) NodeRefImpl<T>(jrdNode.getAddress()));
    }
 
public:
    const Type type;
    unsigned nodFlags;
    ULONG impureOffset;
    const char* dsqlCompatDialectVerb;
    Firebird::Array<NodeRef*> dsqlChildNodes;
    Firebird::Array<NodeRef*> jrdChildNodes;
};

@nmcf · 09.03.2017, 15:13

Не по теме:

Теги поставь.

@mumr · 09.03.2017, 17:46 **[ТС]**

Тогда наводящий вопрос: Могут ли быть в функции не использованы аргументы?

Например:

C++

DmlNode* PathValueNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, const UCHAR blrOp)
{
return NULL;
}

не выдаст так ошибку?

в общем не знаю как избавиться от

, на самом деле это : и p

@nmcf · 09.03.2017, 17:54

Не по теме:

Теги CPP, говорю, поставь на текст программы - никто не станет читать это в таком виде.

Добавлено через 31 секунду

Сообщение от mumr

Могут ли быть в функции не использованы аргументы?

Да.

@mumr · 09.03.2017, 18:08 **[ТС]**

с этим вроде разобрался, в отрыве от всего - работает. тогда с остальным вообще темный лес

Добавлено через 5 минут

Сообщение от nmcf

Теги CPP, говорю, поставь на текст программы - никто не станет читать это в таком виде.

ага, понятно. думал теги темы. поставлю, как сделать, где почитать?

@nmcf · 09.03.2017, 18:09

Не по теме:

Просто выделяешь и жмёшь на панели инструментов C++.

@mumr · 09.03.2017, 18:13 **[ТС]**

Спасибо, тогда вот оно!

Мой класс:

C++

class PathValueNode : public TypedNode<ValueExprNode, ExprNode::TYPE_PATH>
{
public:
explicit PathValueNode(MemoryPool& pool);
 
static DmlNode* parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, const UCHAR blrOp);
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch);
virtual Firebird::string internalPrint(NodePrinter& printer) const;
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
virtual bool setParameterType(DsqlCompilerScratch* dsqlScratch,
const dsc* desc, bool forceVarChar)
{
return false;
}
 
virtual void setParameterName(dsql_par* parameter) const;
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc);
 
virtual ValueExprNode* dsqlFieldRemapper(FieldRemapper& visitor)
{
ExprNode::dsqlFieldRemapper(visitor);
return this;
}
 
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb)
{
ExprNode:ass1(tdbb, csb);
return this;
}
 
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb)
{
ExprNode:ass2(tdbb, csb);
return this;
}
 
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc);
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const;
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const;
 
public:
Firebird::Array<NestConst<PathNode>> path;
};

Реализация метода для примера:

C++

DmlNode* PathValueNode:arse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* csb, const UCHAR blrOp)
{
return NULL;
}

Родительский класс:

C++

class ValueExprNode : public ExprNode
{
public:
ValueExprNode(Type aType, MemoryPool& pool)
: ExprNode(aType, pool, KIND_VALUE),
nodScale(0)
{
nodDesc.clear();
}
 
public:
virtual Firebird::string internalPrint(NodePrinter& printer) const = 0;
 
virtual ValueExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch)
{
ExprNode::dsqlPass(dsqlScratch);
return this;
}
 
virtual bool setParameterType(DsqlCompilerScratch* /*dsqlScratch*/,
const dsc* /*desc*/, bool /*forceVarChar*/)
{
return false;
}
 
virtual void setParameterName(dsql_par* parameter) const = 0;
virtual void make(DsqlCompilerScratch* dsqlScratch, dsc* desc) = 0;
 
virtual ValueExprNode* dsqlFieldRemapper(FieldRemapper& visitor)
{
ExprNode::dsqlFieldRemapper(visitor);
return this;
}
 
virtual ValueExprNode* pass1(thread_db* tdbb, CompilerScratch* csb)
{
ExprNode:ass1(tdbb, csb);
return this;
}
 
virtual ValueExprNode* pass2(thread_db* tdbb, CompilerScratch* csb)
{
ExprNode:ass2(tdbb, csb);
return this;
}
 
// Compute descriptor for value expression.
virtual void getDesc(thread_db* tdbb, CompilerScratch* csb, dsc* desc) = 0;
 
virtual ValueExprNode* copy(thread_db* tdbb, NodeCopier& copier) const = 0;
virtual dsc* execute(thread_db* tdbb, jrd_req* request) const = 0;
 
public:
SCHAR nodScale;
dsc nodDesc;
};

Родитель родителя:

C++

class ExprNode : public DmlNode
{
public:
enum Type
{
// Value types
TYPE_AGGREGATE,
TYPE_ALIAS,
TYPE_ARITHMETIC,
TYPE_ARRAY,
TYPE_BOOL_AS_VALUE,
TYPE_CAST,
TYPE_COALESCE,
TYPE_COLLATE,
TYPE_CONCATENATE,
TYPE_CURRENT_DATE,
TYPE_CURRENT_TIME,
TYPE_CURRENT_TIMESTAMP,
TYPE_CURRENT_ROLE,
TYPE_CURRENT_USER,
TYPE_DERIVED_EXPR,
TYPE_DECODE,
TYPE_DERIVED_FIELD,
TYPE_DOMAIN_VALIDATION,
TYPE_EXTRACT,
TYPE_FIELD,
TYPE_GEN_ID,
TYPE_INTERNAL_INFO,
TYPE_LITERAL,
TYPE_MAP,
TYPE_NEGATE,
TYPE_NULL,
TYPE_ORDER,
TYPE_OVER,
TYPE_PARAMETER,
TYPE_RECORD_KEY,
TYPE_SCALAR,
TYPE_STMT_EXPR,
TYPE_STR_CASE,
TYPE_STR_LEN,
TYPE_SUBQUERY,
TYPE_SUBSTRING,
TYPE_SUBSTRING_SIMILAR,
TYPE_SYSFUNC_CALL,
TYPE_TRIM,
TYPE_UDF_CALL,
TYPE_VALUE_IF,
TYPE_VARIABLE,
 
// Bool types
TYPE_BINARY_BOOL,
TYPE_COMPARATIVE_BOOL,
TYPE_MISSING_BOOL,
TYPE_NOT_BOOL,
TYPE_RSE_BOOL,
 
// RecordSource types
TYPE_AGGREGATE_SOURCE,
TYPE_PROCEDURE,
TYPE_RELATION,
TYPE_RSE,
TYPE_SELECT_EXPR,
TYPE_UNION,
TYPE_WINDOW,
 
// List types
TYPE_REC_SOURCE_LIST,
TYPE_VALUE_LIST
#ifdef _RxO
, TYPE_CLASS,
TYPE_PATH
#endif
};
 
// Generic flags.
static const unsigned FLAG_INVARIANT    = 0x01; // Node is recognized as being invariant.
 
// Boolean flags.
static const unsigned FLAG_DEOPTIMIZE   = 0x02; // Boolean which requires deoptimization.
static const unsigned FLAG_RESIDUAL = 0x04; // Boolean which must remain residual.
static const unsigned FLAG_ANSI_NOT = 0x08; // ANY/ALL predicate is prefixed with a NOT one.
 
// Value flags.
static const unsigned FLAG_DOUBLE   = 0x10;
static const unsigned FLAG_DATE = 0x20;
static const unsigned FLAG_VALUE    = 0x40; // Full value area required in impure space.
 
explicit ExprNode(Type aType, MemoryPool& pool, Kind aKind)
: DmlNode(pool, aKind),
type(aType),
nodFlags(0),
impureOffset(0),
dsqlCompatDialectVerb(NULL),
dsqlChildNodes(pool),
jrdChildNodes(pool)
{
}
 
template <typename T> T* as()
{
const ExprNode* const thisPointer = this;   // avoid warning
return thisPointer && type == T::TYPE ? static_cast<T*>(this) : NULL;
}
 
template <typename T> const T* as() const
{
const ExprNode* const thisPointer = this;   // avoid warning
return thisPointer && type == T::TYPE ? static_cast<const T*>(this) : NULL;
}
 
template <typename T> bool is() const
{
const ExprNode* const thisPointer = this;   // avoid warning
return thisPointer && type == T::TYPE;
}
 
template <typename T, typename LegacyType> static T* as(LegacyType* node)
{
return node ? node->template as<T>() : NULL;
}
 
template <typename T, typename LegacyType> static const T* as(const LegacyType* node)
{
return node ? node->template as<T>() : NULL;
}
 
template <typename T, typename LegacyType> static bool is(const LegacyType* node)
{
return node ? node->template is<T>() : false;
}
 
// Allocate and assign impure space for various nodes.
template <typename T> static void doPass2(thread_db* tdbb, CompilerScratch* csb, T** node)
{
if (!*node)
return;
 
*node = (*node)->pass2(tdbb, csb);
}
 
virtual Firebird::string internalPrint(NodePrinter& printer) const = 0;
 
virtual bool dsqlAggregateFinder(AggregateFinder& visitor)
{
bool ret = false;
 
for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
ret |= visitor.visit((*i)->getExpr());
 
return ret;
}
 
virtual bool dsqlAggregate2Finder(Aggregate2Finder& visitor)
{
bool ret = false;
 
for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
ret |= visitor.visit((*i)->getExpr());
 
return ret;
}
 
virtual bool dsqlFieldFinder(FieldFinder& visitor)
{
bool ret = false;
 
for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
ret |= visitor.visit((*i)->getExpr());
 
return ret;
}
 
virtual bool dsqlInvalidReferenceFinder(InvalidReferenceFinder& visitor)
{
bool ret = false;
 
for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
ret |= visitor.visit((*i)->getExpr());
 
return ret;
}
 
virtual bool dsqlSubSelectFinder(SubSelectFinder& visitor)
{
bool ret = false;
 
for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
ret |= visitor.visit((*i)->getExpr());
 
return ret;
}
 
virtual ExprNode* dsqlFieldRemapper(FieldRemapper& visitor)
{
for (NodeRef* const* i = dsqlChildNodes.begin(); i != dsqlChildNodes.end(); ++i)
(*i)->remap(visitor);
 
return this;
}
 
template <typename T>
static void doDsqlFieldRemapper(FieldRemapper& visitor, NestConst<T>& node)
{
if (node)
node = node->dsqlFieldRemapper(visitor);
}
 
template <typename T1, typename T2>
static void doDsqlFieldRemapper(FieldRemapper& visitor, NestConst<T1>& target, NestConst<T2> node)
{
target = node ? node->dsqlFieldRemapper(visitor) : NULL;
}
 
// Check if expression could return NULL or expression can turn NULL into a true/false.
virtual bool possiblyUnknown()
{
for (NodeRef** i = jrdChildNodes.begin(); i != jrdChildNodes.end(); ++i)
{
if (**i && (*i)->getExpr()->possiblyUnknown())
return true;
}
 
return false;
}
 
// Verify if this node is allowed in an unmapped boolean.
virtual bool unmappable(const MapNode* mapNode, StreamType shellStream)
{
for (NodeRef** i = jrdChildNodes.begin(); i != jrdChildNodes.end(); ++i)
{
if (**i && !(*i)->getExpr()->unmappable(mapNode, shellStream))
return false;
}
 
return true;
}
 
// Return all streams referenced by the expression.
virtual void collectStreams(SortedStreamList& streamList) const
{
for (const NodeRef* const* i = jrdChildNodes.begin(); i != jrdChildNodes.end(); ++i)
{
if (**i)
(*i)->getExpr()->collectStreams(streamList);
}
}
 
virtual bool findStream(StreamType stream)
{
SortedStreamList streams;
collectStreams(streams);
 
return streams.exist(stream);
}
 
virtual bool dsqlMatch(const ExprNode* other, bool ignoreMapCast) const;
 
virtual ExprNode* dsqlPass(DsqlCompilerScratch* dsqlScratch)
{
DmlNode::dsqlPass(dsqlScratch);
return this;
}
 
// Determine if two expression trees are the same.
virtual bool sameAs(const ExprNode* other, bool ignoreStreams) const;
 
// See if node is presently computable.
// A node is said to be computable, if all the streams involved
// in that node are csb_active. The csb_active flag defines
// all the streams available in the current scope of the query.
virtual bool computable(CompilerScratch* csb, StreamType stream,
bool allowOnlyCurrentStream, ValueExprNode* value = NULL);
 
virtual void findDependentFromStreams(const OptimizerRetrieval* optRet,
SortedStreamList* streamList);
virtual ExprNode* pass1(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* pass2(thread_db* tdbb, CompilerScratch* csb);
virtual ExprNode* copy(thread_db* tdbb, NodeCopier& copier) const = 0;
 
protected:
template <typename T1, typename T2>
void addChildNode(NestConst<T1>& dsqlNode, NestConst<T2>& jrdNode)
{
addDsqlChildNode(dsqlNode);
addChildNode(jrdNode);
}
 
template <typename T>
void addDsqlChildNode(NestConst<T>& dsqlNode)
{
dsqlChildNodes.add(FB_NEW_POOL(getPool()) NodeRefImpl<T>(dsqlNode.getAddress()));
}
 
template <typename T>
void addChildNode(NestConst<T>& jrdNode)
{
jrdChildNodes.add(FB_NEW_POOL(getPool()) NodeRefImpl<T>(jrdNode.getAddress()));
}
 
public:
const Type type;
unsigned nodFlags;
ULONG impureOffset;
const char* dsqlCompatDialectVerb;
Firebird::Array<NodeRef*> dsqlChildNodes;
Firebird::Array<NodeRef*> jrdChildNodes;
};

@nmcf · 09.03.2017, 18:56

А что такое TypedNode? Ты наследуешь свой класс не от ValueExprNode, а от какого-то шаблона?

@mumr · 09.03.2017, 20:42 **[ТС]**

ну собственно да, как я понимаю этот шаблон как раз и делает PathValueNode наследником ValueExprNode

вот он:

C++

template <typename T, typename T::Type typeConst>
class TypedNode : public T
{
public:
    explicit TypedNode(MemoryPool& pool)
        : T(typeConst, pool)
    {
    }
 
public:
    const static typename T::Type TYPE = typeConst;
};

@nmcf
	09.03.2017, 15:13 #2
	Не по теме: Теги поставь. 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,672
	09.03.2017, 17:54	4
	Не по теме: Теги CPP, говорю, поставь на текст программы - никто не станет читать это в таком виде. Добавлено через 31 секунду Сообщение от mumr Могут ли быть в функции не использованы аргументы? Да. 1

@mumr 0 / 0 / 0 Регистрация: 09.03.2017 Сообщений: 7
	09.03.2017, 18:08 [ТС]	5
	с этим вроде разобрался, в отрыве от всего - работает. тогда с остальным вообще темный лес Добавлено через 5 минут Сообщение от nmcf Теги CPP, говорю, поставь на текст программы - никто не станет читать это в таком виде. ага, понятно. думал теги темы. поставлю, как сделать, где почитать? 0

@nmcf
	09.03.2017, 18:09 #6
	Не по теме: Просто выделяешь и жмёшь на панели инструментов C++. 0

@nmcf 7793 / 6560 / 2984 Регистрация: 14.04.2014 Сообщений: 28,672
	09.03.2017, 18:56	8
	А что такое TypedNode? Ты наследуешь свой класс не от ValueExprNode, а от какого-то шаблона? 1

	09.03.2017, 20:42