Указатель NULL
- это тот, который указывает на никуда. Когда вы разыскиваете указатель p
, вы говорите «дайте мне данные в месте, хранящемся в« p ». Когда p
является нулевым указателем, местоположение, хранящееся в p
, является nowhere
, вы говорите «Дайте мне данные в месте« нигде ». Очевидно, он не может этого сделать, поэтому он выбрасывает NULL pointer exception
.
В общем, это потому, что что-то не было правильно инициализировано.
В то время как Ваше решение должно работать, может быть трудно читать в зависимости от уровня квалификации Ваших коллег - программистов. Кроме того, это отодвигает функциональность от сайта вызова. Который может сделать обслуживание немного более трудным.
я не уверен, состоит ли Ваша цель в том, чтобы получить ключи в вектор или распечатать их в суд, таким образом, я делаю обоих. Можно попробовать что-то вроде этого:
map<int, int> m;
vector<int> v;
for(map<int,int>::iterator it = m.begin(); it != m.end(); ++it) {
v.push_back(it->first);
cout << it->first << "\n";
}
Или еще более простой, если Вы используете Повышение:
map<int,int> m;
pair<int,int> me; // what a map<int, int> is made of
vector<int> v;
BOOST_FOREACH(me, m) {
v.push_back(me.first);
cout << me.first << "\n";
}
Лично, мне нравится версия BOOST_FOREACH, потому что там меньше вводит, и это очень явно о том, что это делает.
(я всегда задаюсь вопросом почему станд.:: карта не включает функцию членства для нас, чтобы сделать так.)
, поскольку это не может сделать этого немного лучше, чем Вы, может сделать это. Если реализация метода не будет никаким начальником к реализации бесплатной функции тогда в целом, Вы не должны писать метод; необходимо записать бесплатную функцию.
Это также не сразу понятно, почему это полезно так или иначе.
Кроме того, если у Вас есть Повышение, используйте transform_iterator, чтобы не делать временную копию ключей.
Можно использовать универсальное повышение:: transform_iterator. transform_iterator позволяет Вам преобразовывать выполненные с помощью итераций значения, например, в нашем случае, когда Вы хотите иметь дело только с ключами, не значениями. См. http://www.boost.org/doc/libs/1_36_0/libs/iterator/doc/transform_iterator.html#example
Я думаю, что BOOST_FOREACH, представленный выше, является хорошим и чистым, однако, существует другая опция с помощью ПОВЫШЕНИЯ также.
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
std::map<int, int> m;
std::vector<int> keys;
using namespace boost::lambda;
transform( m.begin(),
m.end(),
back_inserter(keys),
bind( &std::map<int,int>::value_type::first, _1 )
);
copy( keys.begin(), keys.end(), std::ostream_iterator<int>(std::cout, "\n") );
Лично, я не думаю, что этот подход является столь же чистым как подход BOOST_FOREACH в этом случае, но повышение:: лямбда может быть действительно чистой в других случаях.
STL SGI имеет расширение, названное select1st
. Слишком плохо это не находится в стандартном STL!
Ваше решение прекрасно, но можно использовать итератор, чтобы сделать это:
std::map<int, int> m;
m.insert(std::pair<int, int>(3, 4));
m.insert(std::pair<int, int>(5, 6));
for(std::map<int, int>::const_iterator it = m.begin(); it != m.end(); it++)
{
int key = it->first;
int value = it->second;
//Do something
}
Лучшее решение STL без sgi и без ускорения - это расширить map :: iterator следующим образом:
template<class map_type>
class key_iterator : public map_type::iterator
{
public:
typedef typename map_type::iterator map_iterator;
typedef typename map_iterator::value_type::first_type key_type;
key_iterator(const map_iterator& other) : map_type::iterator(other) {} ;
key_type& operator *()
{
return map_type::iterator::operator*().first;
}
};
// helpers to create iterators easier:
template<class map_type>
key_iterator<map_type> key_begin(map_type& m)
{
return key_iterator<map_type>(m.begin());
}
template<class map_type>
key_iterator<map_type> key_end(map_type& m)
{
return key_iterator<map_type>(m.end());
}
, а затем использовать их так:
map<string,int> test;
test["one"] = 1;
test["two"] = 2;
vector<string> keys;
// // method one
// key_iterator<map<string,int> > kb(test.begin());
// key_iterator<map<string,int> > ke(test.end());
// keys.insert(keys.begin(), kb, ke);
// // method two
// keys.insert(keys.begin(),
// key_iterator<map<string,int> >(test.begin()),
// key_iterator<map<string,int> >(test.end()));
// method three (with helpers)
keys.insert(keys.begin(), key_begin(test), key_end(test));
string one = keys[0];
C ++ 0x дал нам еще одно отличное решение:
std::vector<int> keys;
std::transform(
m_Inputs.begin(),
m_Inputs.end(),
std::back_inserter(keys),
[](const std::map<int,int>::value_type &pair){return pair.first;});