Почему я получаю сообщение об ошибке "формирование ссылки на ссылочный тип"?
Какая альтернатива, если мне нужно использовать ссылку, и данные, которые я передаю, я не могу изменить тип, поэтому я не могу хранить указатель на него?
Код:
#include <map>
#include<iostream>
#include<string>
using namespace std;
int main()
{
string test;
pair<string, string> p=pair<string, string>("Foo","Bar");
map<pair<string, string>, string&> m;
m[make_pair("aa","bb")]=test;
return 0;
}
Ошибка:
$g++ MapPair.cpp /usr/include/c ++/3.2.3/bits/stl_map.h: При создании std::map<std::pair<std::string,
std::string>, std::string&,
std::less<std::pair<std::string,
std::string> >,
std::allocator<std::pair<const
std::pair<std::string, std::string>,
std::string&> > >': MapPair.cpp:15:
instantiated from here
/usr/include/c++/3.2.3/bits/stl_map.h:221:
forming reference to reference type
std::string &" MapPair.cpp: В function int main()': MapPair.cpp:16:
no match for
std:: map, std::string &, std:: less > ,
станд:: распределитель,
std::string & → > & Оператор [std:: pair] ' /usr/include/c ++/3.2.3/bits/stl_pair.h: В глобальном масштабе: /usr/include/c ++/3.2.3/bits/stl_pair.h: При создании std::pair<const
std::pair<std::string, std::string>,
std::string&>':
/usr/include/c++/3.2.3/bits/stl_tree.h:122:
instantiated from
std:: _ Rb_tree_node
Что я делаю неправильно, чтобы вызвать это сообщение?
Ответы
Ответ 1
Вы не можете хранить ссылки. Ссылки - это просто псевдонимы для другой переменной.
Для сохранения карты требуется копия строки:
map<pair<string, string>, string> m;
Причина, по которой вы получаете эту конкретную ошибку, - это то, что где-то на карте она будет выполнять операцию над mapped_type
, которая в вашем случае string&
. Одна из этих операций (например, в operator[]
, например) вернет ссылку на mapped_type
:
mapped_type& operator[](const key_type&)
Что, с вашим mapped_type
, будет:
string&& operator[](const key_type& _Keyval)
И вы не можете иметь ссылку на ссылку:
Стандарт 8.3.4:
Не должно быть ссылок на ссылки, нет массивов ссылок и ссылок на ссылки.
С другой стороны, я бы рекомендовал использовать typedef
, чтобы ваш код был легче читать:
int main()
{
typedef pair<string, string> StringPair;
typedef map<StringPair, string> StringPairMap;
string test;
StringPair p("Foo","Bar");
StringPairMap m;
m[make_pair("aa","bb")] = test;
return 0;
}
Ответ 2
Предыдущие ответы здесь устарели. Сегодня мы имеем std::reference_wrapper
как часть стандарта С++ 11:
#include <map>
#include <iostream>
#include <string>
using namespace std;
int main()
{
string test;
pair<string, string> p = pair<string, string>("Foo", "Bar");
map<pair<string, string>, reference_wrapper<string>> m;
m[make_pair("aa", "bb")] = test;
return 0;
}
Std:: reference_wrapper будет неявно преобразовывать ссылку на свой внутренний тип, но это не работает в некоторых контекстах, и в этом случае вы вызываете .get()
для доступа.
http://en.cppreference.com/w/cpp/utility/functional/reference_wrapper
Ответ 3
Вы можете использовать boost:: reference_wrapper для хранения ссылок в контейнерах STL. Вот ваш пример, измененный (не проверенный и, безусловно, не очень хорошо написанный, просто иллюстрирует точку)
#include <map>
#include<iostream>
#include<string>
#include <boost/ref.hpp>
int main()
{
typedef std::pair< std::string, std::string> PairType;
typedef std::map< PairType, boost::reference_wrapper<std::string> > MapType;
std::string test = "Hello there!!";
MapType m;
PairType pp = std::make_pair("aa","bb");
m.insert(std::make_pair(pp , boost::ref(test) ) );
MapType::iterator it (m.find( pp ) );
if(it != m.end())
{
std::cout << it->second.get() << std::endl;
}
//change test
test = "I am different now";
std::cout << it->second.get() << std::endl;
return 0;
}
Ответ 4
Вы не можете использовать ссылки как val, из-за того, как создается шаблон. Вместо этого вы можете использовать указатель.
Ответ 5
По существу, возникает вопрос, можете ли вы использовать ссылки в контейнерах. Конечно, вы можете IF правильно подготовить свой класс И к своему контейнеру. Я демонстрирую это ниже с помощью двух простых векторных контейнеров: vectoref
, который изменяет std::vector<>
, а другой, vec
, который реализуется с нуля.
#include <iostream>
#include <vector>
// requires compilation with --std=c++11 (at least)
using namespace std;
class A {
int _a; // this is our true data
A *_p; // this is to cheat the compiler
public:
A(int n = 0) : _a(n), _p(0)
{ cout << "A constructor (" << this << "," << _a << ")\n"; }
// constructor used by the initializer_list (cheating the compiler)
A(const A& r) : _p(const_cast<A *>(&r))
{ cout << "A copy constructor (" << this << "<-" << &r << ")\n"; }
void print() const {cout << "A instance: " << this << "," << _a << "\n";}
~A() {cout << "A(" << this << "," << _a << ") destructor.\n";}
// just to see what is copied implicitly
A& operator=(const A& r) {
cout << "A instance copied (" << this << "," << _a << ")\n";
_a = r._a; _p = r._p;
return *this;
}
// just in case you want to check if instance is pure or fake
bool is_fake() const {return _p != 0;}
A *ptr() const {return _p;}
};
template<typename T, int sz>
class vec { // vector class using initializer_list of A-references!!
public:
const T *a[sz]; // store as pointers, retrieve as references
// because asignment to a reference causes copy operator to be invoked
int cur;
vec() : cur(0) {}
vec(std::initializer_list<T> l) : cur(0) {
cout << "construct using initializer list.\n";
for (auto& t : l) // expecting fake elements
a[cur++] = t.ptr();
}
const T& operator[](int i) {return *a[i];}
// expecting pure elements
vec& push_back(const T& r) {a[cur++] = &r; return *this;}
void copy_from(vec&& r) {
for (int i = 0; i < r.cur; ++i)
push_back(r[i]);
}
};
template<typename T>
class vectoref : public vector<T *> { // similar to vec but extending std::vector<>
using size_type = typename vector<T*>::size_type;
public:
vectoref() {}
vectoref(std::initializer_list<T> l) {
cout << "construct using initializer list.\n";
for (auto& t : l) // expecting fake elements
vector<T*>::push_back(t.ptr());
}
const T& operator[](size_type i) {return *vector<T*>::at(i);}
// expecting pure elements
vectoref& push_back(const T& r)
{ vector<T*>::push_back(&r); return *this; }
void copy_from(const vectoref&& r) {
for (size_type i = 0; i < r.size(); ++i)
vectoref<T>::push_back(r[i]);
}
};
class X { // user of initializer_list of A
public:
X() {}
void f(initializer_list<A> l) const {
cout << "In f({...}):\n";
for (auto& a : l)
a.ptr()->print();
}
};
int main()
{
A a(7), b(24), c(80);
cout << "----------------------------------\n";
vectoref<A> w{a,a,b,c}; // alternatively, use next line
// vec<A,5> w{a,a,b,c}; // 5-th element undefined
w[0].print();
w[3].print();
cout << "----------------------------------\n";
X x;
x.f({a,b,c,a,b,c,b,a});
cout << "==================================\n";
return 0;
}