Повысить карму: как работает этот неявный вызов transform_attribute? (или нет?)

У меня есть следующий фрагмент кода, который, кажется, работает нормально (я основал семантические действия на повторно использовать проанализированную переменную с повышенной кармой).

#include <iostream>
#include <iterator>
#include <memory>
#include <string>
#include <vector>

#include <boost/fusion/include/adapt_struct.hpp>
#include <boost/fusion/include/sequence.hpp>
#include <boost/spirit/include/karma.hpp>
#include <boost/spirit/include/phoenix_core.hpp>
#include <boost/spirit/include/phoenix_operator.hpp>
#include <boost/spirit/include/phoenix_fusion.hpp>
#include <boost/spirit/include/phoenix_bind.hpp>
#include <boost/spirit/include/support_attributes.hpp>
#include <boost/spirit/include/support_adapt_adt_attributes.hpp>

using namespace boost::spirit;

struct DataElement
{
DataElement(const std::string& s) : str_(s) {}

const std::string& str() const { return str_; }
std::string& str() { return str_; }
std::string str_;
};
using Data = std::vector<std::shared_ptr<const DataElement>>;

namespace boost {
namespace spirit {
namespace traits {

template<>
struct transform_attribute<std::shared_ptr<const DataElement> const, const DataElement&, karma::domain>
{
using type = const DataElement&;
static type pre(const std::shared_ptr<const DataElement>& val) { return *val; }
};

}
}
}

BOOST_FUSION_ADAPT_ADT(
DataElement,
(std::string&, const std::string&, obj.str(), obj.str())
);

template<typename Iterator>
struct TheGrammar: public karma::grammar<Iterator, Data()>
{
TheGrammar(): karma::grammar<Iterator, Data()>(start)
{
start %= -(elt % karma::eol);
elt %=
karma::lit("'some prefix'")
<< karma::string [karma::_1 = boost::phoenix::at_c<0>(karma::_val)]
<< karma::lit("'some infix 1'")
<< karma::string [karma::_1 = boost::phoenix::at_c<0>(karma::_val)]
<< karma::lit("'some infix 2'")
<< karma::string [karma::_1 = boost::phoenix::at_c<0>(karma::_val)]
<< karma::lit("'some suffix'")
;
}

karma::rule<Iterator, Data()> start;
karma::rule<Iterator, const DataElement&()> elt;
};

int main(void)
{
Data vec = {
std::make_shared<DataElement>("one"),
std::make_shared<DataElement>("two"),
std::make_shared<DataElement>("three"),
std::make_shared<DataElement>("four"),
std::make_shared<DataElement>("five"),
std::make_shared<DataElement>("six"),
std::make_shared<DataElement>("seven"),
std::make_shared<DataElement>("eight"),
};
using iterator_type = std::ostream_iterator<char>;
iterator_type out(std::cout);

TheGrammar<iterator_type> grammar;
return karma::generate(out, grammar, vec);
}

Я хотел бы понять пару вещей:

1. Почему мне не нужно использовать karma::attr_cast в любом месте? мой start Правило это вектор std::shared_ptr тогда как elt правило действует на фактическую ссылку на объект const. Я изначально пробовал attr_cast но не получилось, и вроде как попробовал эту версию только от всего сердца, на случай, если она сработает, и сработало …
2. Почему он все еще компилируется, если я закомментирую свой обычай transform_attribute вообще? Есть ли какой-то по умолчанию std::shared_ptr<T> -> T& transform_attribute предоставлен? Я не мог найти много, но, возможно, я не смотрю в нужном месте?
3. Если я закомментирую свой обычай transform_attributeКак уже упоминалось выше, код все еще скомпилирован, но во время выполнения явно наблюдается некоторое повреждение памяти. karma::string генерировать мусор. В некотором смысле, я могу понять, что должно происходить что-то смешное, так как я даже не говорю карме, как получить от моего shared_ptr к объектам. Является ли факт, что он компилирует фактическую ошибку / ошибку?

Большое спасибо за ваше время и помощь!