c++ - 从 vector 中的父基转换的模板化子 T 生成的虚假字符

Question

<分区>

Answer 1

如评论中所述，此代码中最大的问题是object slicing并解决这个问题，您应该使用基类指针或引用。在 vector你可以存储指针但不能存储真正的引用(尽管你可以使用 std::reference_wrapper)。

您必须决定 vector 是否应该拥有这些对象，或者它是否应该只保留指向对象的指针，这些对象的生命周期与 vector 分开控制。

std::vector<BaseClass*> v1;           // objects will live on even when the vector is destroyed
std::vector<std::unique_ptr<BaseClass>> v2; // objects are destroyed if the vector is destroyed

在您的测试代码中，您使用了第一个选项，所以我将采用第一个选项，但更改它很容易(而且通常更可取)。

以下是如何进行所需更改的想法。我希望代码中的注释解释了大部分内容。

属性.h

// add a header guard to not accidentally include it into the same translation unit more than once
#ifndef ATTRIBUTE_H
#define ATTRIBUTE_H

#include <iostream>
#include <string>
#include <typeinfo> // typeid()

using String = std::string;

// An abstract base class for all Attribute<T>'s
// Since "key" is common for them all, I've put it in here.
class AttributeBase {
public:
    AttributeBase(const String& k) : key(k) {}
    virtual ~AttributeBase() = 0; // pure virtual

    String const& getKey() const {
        return key;
    };

    // all descendants must implement a print method
    virtual std::ostream& print(std::ostream&) const = 0;

    // trust all Attribute<T>'s to get direct access to private members
    template<typename T>
    friend class Attribute;
private:
    String key;
};

// AttributeBase is an abstract base class but with a default
// destructor to not force descendants to have to implement it.
AttributeBase::~AttributeBase() {}

// streaming out any AttributeBase descendant will, via this method, call the virtual
// print() method that descendants must override 
std::ostream& operator<<(std::ostream& os, const AttributeBase& ab) {
    return ab.print(os);
}

template<class T>
class Attribute : public AttributeBase {
public:
    using value_type = T;

    Attribute(const String& Key, const T& Value) :
        AttributeBase(Key),
        value(Value)
    {}

    T const& getValue() const {
        return value;
    }

    std::ostream& print(std::ostream& os) const override {
        // Print an implementation defined name for the type using typeid()
        // and then "key" and "value".
        // Direct access to "key" works because of the "friend"
        // declaration in AttributeBase. We could have used getKey()
        // though, but this shows one use of "friend".
        return
            os << "type:  " << typeid(value).name() << "\n"
               << "key:   " << key << "\n"
               << "value: " << value << "\n";
    }

private:
    T value;
};

// end of header guard
#endif

线束.cpp

// include your own headers first to catch include chain errors more easily
#include "Attribute.h"

#include <iostream>
#include <vector>
#include <memory>

// using namespace std; // bad practice:
// https://stackoverflow.com/questions/1452721/why-is-using-namespace-std-considered-bad-practice

using String = std::string;

int main()
{
    // TEST THE Attribute CLASS BY ITSELF
    // in the following functions we're using the added operator<< to let the objects
    // print their own values

    Attribute <String> att("testkey","testvalue");
    std::cout << "-- att --\n" << att << "\n";

    // TEST SIX INSTANCES OF Attribute CLASS BEFORE ADDING TO attvec

    // use base class pointers to avoid slicing
    std::vector<AttributeBase*> attvec;

    Attribute<String> q("key1","one");
    std::cout << "-- q ---\n" << q << "\n";

    Attribute<String> w("key2","two");
    std::cout << "-- w ---\n" << w << "\n";

    Attribute<String> e("key3","three");
    std::cout << "-- e --\n" << e << "\n";

    Attribute<int> r("key4",4);
    std::cout << "-- r --\n" << r << "\n";

    Attribute<int> t("key5",5);
    std::cout << "-- t --\n" << t << "\n";

    Attribute<int> y("key6",6);
    std::cout << "-- y --\n" << y << "\n";

    // added a 7:th object with a different type

    Attribute<double> u("key7", 7.12345);
    std::cout << "-- u --\n" << u << "\n";

    // put pointers to the objects in the vector
    attvec.push_back(&q);
    attvec.push_back(&w);
    attvec.push_back(&e);
    attvec.push_back(&r);
    attvec.push_back(&t);
    attvec.push_back(&y);
    attvec.push_back(&u);

    // TEST ALL Attribute CLASS INSTANCES AS EXTRACTED FROM A vector
    std::cout << "--\n";

    for (AttributeBase const* baseObject : attvec) {

        // try to dynamic_cast to the types for which you have special handling
        // if( <init> ; <condition> ) { ...

        if(auto pChild = dynamic_cast<Attribute<String> const*>(baseObject); pChild)
        {
            std::cout << "T (String)\n";
            const String sKey = pChild->getKey();
            std::cout << "Key: " << sKey << "\n";
            const String sValue = pChild->getValue();
            std::cout << "Value: " << sValue << "\n";
            // or let the user defined streaming operator for the type do the work:
            std::cout << *pChild << "\n\n";
        }
        else if(auto pChild = dynamic_cast<Attribute<int> const*>(baseObject); pChild)
        {
            std::cout << "T (int)\n";
            const String sKey = pChild->getKey();
            std::cout << "Key: " << sKey << "\n";
            const int iValue = pChild->getValue();
            std::cout << "Value: " << iValue << "\n";
            // or let the user defined streaming operator for the type do the work:
            std::cout << *pChild << "\n\n";
        } else {
            std::cout << "T (generic)\n";
            const String sKey = baseObject->getKey();
            std::cout << "Key: " << sKey << "\n";
            /* the getValue() method does not exist in the base class
            auto genValue = baseObject->getValue();
            cout << "Value: " << genValue << "\n";
            */
            // or let the user defined streaming operator for the type do the work:
            std::cout << *baseObject << "\n";
        }
    }
}

我删除了对 Attributes.cpp 的依赖在 makefile 中，以便您可以删除该文件。我还添加了一些在追查错误时可以派上用场的东西，并制定了映射的通用规则 <file>.cpp至 obj/<file>.o .我用 gmake所以它可能包含 gmake使它在你这边失败的具体事情。在这种情况下请忽略它。有些选项可能仍然有用。

生成文件

CC=c++

MINIMAL_WARNINGS=-Wall -Wextra -pedantic

BONUS_WARNINGS=-Werror -Wshadow -Weffc++ -Wconversion -Wsign-conversion -Woverloaded-virtual \
               -Wold-style-cast -Wwrite-strings -Wcast-qual -Wnoexcept -Wnoexcept-type \
               -Wpessimizing-move -Wredundant-move -Wstrict-null-sentinel -Wunreachable-code \
               -Wnull-dereference -Wsequence-point -pedantic-errors

# scan-build — Clang static analyzer
STATIC_ANALYSIS = scan-build -v --force-analyze-debug-code

# SANITIZER options using libasan.
# libasan - good for catching and displaying misc errors in runtime instead of just resulting
#           in a "Segmentation fault (core dumped)".
SANITIZER=-fsanitize=undefined -fsanitize=address

# turn on the bonus warnings if you'd like to fix misc things that are usually good to fix.
#WARNINGS=$(MINIMAL_WARNINGS) $(BONUS_WARNINGS)
WARNINGS=$(MINIMAL_WARNINGS)

FLAGS=-g3 -std=c++17 $(WARNINGS)

# collect all your .cpp files - remember to remove Attribute.cpp
SRC=$(wildcard *.cpp)

# Create a list of object files needed before linking.
# For each "%.cpp" file in SRC, "obj/%.o" will be put in OBJS.
OBJS=$(patsubst %.cpp,obj/%.o,$(SRC))

TARGETS=harness

All: $(TARGETS)

harness: $(OBJS)
        @# turn on SANITIZER on if you have libasan installed (linking will fail if you dont)
        @#$(CC) $(FLAGS) $(SANITIZER) -o harness $(OBJS)
        $(CC) $(FLAGS) -o harness $(OBJS)

# A generic object file rule. It requires a .cpp file and that the obj directory exists.
obj/%.o : %.cpp obj Attribute.h
        @# turn on STATIC_ANALYSIS if you have scan-build installed
        @#$(STATIC_ANALYSIS) $(CC) $(FLAGS) -c -o $@ $<
        $(CC) $(FLAGS) -c -o $@ $<

# The object directory target
obj:
        mkdir -p obj

clean:
        rm -rf obj $(TARGETS)