При попытке распарсить в одном правиле больше девяти аргументов валятся ошибки о некорректности подстановочных символов qi::_10, qi::_11 и т.д., хотя задан define, требуемый документацией. Где я ошибся, и как это поправить?
Правильно ли я понимаю, что для получения boost::thread_interrupted от join-а потока необходимо до него вызвать на этот поток interrupt? Заранее спасибо.
Вот интересно мне стало, в соответствующей статье НК РФ про тот самый транспортный налог расписываются всякие мелочи и подробности того, как выплачивать этот налог, но ни слова о том, куда, на какие цели, должны идти мною уплаченные деньги. Есть ли вообще возможность (хоть в одной стране мира) получить официальное объяснение, на какие цели должен быть истрачен конкретный налог? Или же налоговая база формируется "от балды", типа "А давайте введём налог на вот эту херню? — А отчего бы и не ввести?".
Есть "главный" репозиторий hg, в который складываются результаты работы, и есть "клиенты" hg, которые эти результаты туда, соответственно, складывают. Хочется настроить оповещения по электропочте о прибытии diff-ов в "главный" репозиторий. Вопрос в том, кто должен заниматься оповещением. Hg "главного" репозитория, или тот hg, кто отправил diff?
По поводу реализации работы со списками в Python: "Я такого пока ещё не видел, явно откуда-то спёрли...".
Доброго всем времени суток. Случилась такая проблема: при попытке завернуть std::get в функциональный объект boost::spirit::phoenix вываливается здоровенный листинг ошибок на предмет того (как я смог понять), что такую сигнатуру использовать не получится. Как можно заставить собираться нижеприведённый код, и можно ли это сделать вообще?
#include <tuple>
#include <vector>
#include <string>
#include <iostream>
//--------------------------------------------------------------------------
#include <boost/spirit/include/qi.hpp>
#include <boost/spirit/include/phoenix.hpp>
//--------------------------------------------------------------------------
/*
g++ -Wall -std=gnu++0x -o ./main ./main.cpp
*/
//--------------------------------------------------------------------------
namespace qi = boost::spirit::qi;
namespace ph = boost::phoenix;
//--------------------------------------------------------------------------
typedef std::tuple<int,int,float> TpPointsTuple;
typedef std::vector<TpPointsTuple> TpPointsTempStorage;
//--------------------------------------------------------------------------
struct phoenix_get_impl
{
template <std::size_t I,typename... Args>
struct result
{
typedef typename std::tuple_element<I,std::tuple<Args...>>::type type;
};
template <std::size_t I,typename... Args>
typename result<I,Args...>::type& operator () (std::tuple<Args...>& t)
{
return std::get<I> (t);
}
};
ph::function<phoenix_get_impl> const phoenix_get = phoenix_get_impl();
//--------------------------------------------------------------------------
struct phoenix_make_tuple_impl
{
template <typename... Args>
struct result
{
typedef std::tuple<Args...> type;
};
template <typename... Args>
typename result<Args...>::type operator () (Args... args) const
{
return std::make_tuple(args...);
}
};
ph::function<phoenix_make_tuple_impl> const phoenix_make_tuple = phoenix_make_tuple_impl();
//--------------------------------------------------------------------------
template <typename Iterator> \
struct TpPointsParser : qi::grammar \
<Iterator,TpPointsTempStorage(),qi::space_type> \
{
TpPointsParser(void) : TpPointsParser::base_type(start)
{
int_strong %= qi::int_ >> !(qi::punct >> *qi::digit);
sectionName = qi::alpha >> *qi::alnum >> qi::lit('=');
requiredData = (int_strong >> int_strong >> -qi::float_) \
[phoenix_make_tuple(qi::_1,qi::_2,qi::_3)];
start = sectionName >> requiredData \
//[ph::push_back(qi::_val,qi::_1)];
[std::cerr << phoenix_get.operator () <0> (qi::_1)];
return;
}
qi::rule<Iterator,int()> int_strong;
qi::rule<Iterator,void(),qi::space_type> sectionName;
qi::rule<Iterator,TpPointsTuple(),qi::space_type> requiredData;
qi::rule<Iterator,TpPointsTempStorage(),qi::space_type> start;
};
//--------------------------------------------------------------------------
int main(int argc,char** argv)
{
//#define USE_IT
#ifdef USE_IT
std::tuple<int,int> t(100500,9000);
phoenix_get_impl pgi;
std::cerr << pgi.operator () <0> (t) << std::endl;
#else
std::string data("point0 = 9000 100500\n");
std::string::const_iterator walker = data.begin();
std::string::const_iterator end = data.end();
bool result = true;
TpPointsTempStorage tpPointsTempStorage;
TpPointsParser<std::string::const_iterator> tpPointsParser;
while((walker != end) && (result == true))
{
result = qi::phrase_parse(walker,end,tpPointsParser,qi::space,tpPointsTempStorage);
std::cerr << std::endl;
}
std::cerr << "tpPointsTempStorage.size() = " \
<< tpPointsTempStorage.size() \
<< std::endl;
#endif//USE_IT
return 0;
}
Для некоего класса требуется создать stl-совместимые итераторы. Как правильнее будет сделать с точки зрения дизайна: отдельные классы для UserIterator и ReverseUserIterator, или сделать один класс итератора с тегом в конструкторе (например), на основании которого будет выбираться поведение?
Скажите, у меня галлюцинации, или действительно на месте удалённого видео лежит слово хуяк?
В QtDesigner-е помимо своих widget-ов есть возможность добавлять и рукописные. И даже есть примеры в документации, как их изготавливать. Класс, который обеспечивает регистрацию рукодельного widget-а, наследует интерфейс QDesignerCustomWidgetInterface. В этом интерфейсе есть функция includeFile, которая, как я понял, должна возвращать строку с заголовочным файлом рукодельного widget-а. В примере (Custom Widget Plugin) возвращается только имя файла, без никто:
QString AnalogClockPlugin::includeFile() const
{
return "analogclock.h";
}
QString AnalogClockPlugin::includeFile() const
{
return "<../examples/designer/customwidgetplugin/analogclock.h>";
}
Что и где я делаю неправильно, кроме того, что использую Qt?
Для разбора конфигурационной строки в Qt-шной программе используется парсер Spirit::Qi. Используется таким образом:
QString value = ... ;// Строка, которую надо разобрать
std::string::const_iterator walker = value.toStdString().begin();// Итератор_1
std::string::const_iterator end = value.toStdString().end();// Итератор_2
parse_data(walker,end,...);// Функция разбора строки
Вопрос в том, насколько корректным будет использование Итератор_1 и Итератор_2. QString::toStdString() каждый раз возвращает временный объект std::string, а я от него беру итератор, и использую в дальнейшем. Оно-то, вроде, работает, но будет ли работать всегда?
Вот уже не первый раз, разворачивая купленную плитку шоколада вижу, что она завёрнута в две бумажки. Но ни разу, заметьте, !НИ РАЗУ! не было такого, чтобы в одной бумажке лежали ДВЕ плитки шоколада. Грустно мне от несправедливости такой.
При компиляции этого чудовищно сложного кода возникает ошибка: error: 'Base' is an inaccessible base of 'Derived'
#include <iostream>
//-------------------------------------------------------------------------
struct Base
{
};
//-------------------------------------------------------------------------
struct Derived : protected Base
{
operator Base* ()
{ return static_cast<Base*>(this); }
Derived* operator & ()
{ return this; }
};
//-------------------------------------------------------------------------
int main(int argc,char** argv)
{
Derived derived;
Base* pbase = static_cast<Base*>(&derived);
return 0;
}
struct Derived : protected Base
{
Derived& operator & ()
{ return *this; }
};
Собссно, subj.
Собссно, subj. Я впал в рекурсию.
В std::ostringstream есть метод fill, который позволяет задать, какими символами будут "залиты" пустые позиции в результирующей строке. Как пример, при заданной ширине вывода 3 символа, и "заливке" в '0' std::stringstream << (int)1 (вроде псевдокода) выведет '001'. Есть ли в Spirit-овской Karma такой же метод? В директивах генератора из управления шириной вывода нашёл лишь maxwidth, но это совсем не то, что нужно.
В документации говорится, что разблокировка ожидающего потока происходит при вызовах condition_variable::notify, condition_variable::notify_all, or spuriously. Какие методы входят в это spuriously? И какое время будет отдано на ожидание? А то пример, приведённый там,
boost::condition_variable cond;
boost::mutex mut;
bool data_ready;
void process_data();
void wait_for_data_to_process()
{
boost::unique_lock<boost::mutex> lock(mut);
while(!data_ready)
{
cond.wait(lock);
}
process_data();
}
выглядит так, будто wait выполняется ограниченное количество времени, и периодически выполняется проверка data_ready.
Читая описание этого механизма, что на педивикии, что в документации boost-а, нахожу огромное сходство с обычной перегрузкой функций. Почему его обозвали не "перегрузкой шаблонов функций", а более другим термином?
Суть такова: с прибора приходят результаты измерений в формате, к примеру, double. С третьего-четвёртого разрядов после точки измеренное значение меняется от замера к замеру (неточности измерений, помехи всякие). Есть ли возможность средствами C++-stdlib, либо boost, ограничить точность после точки на уровне заданного разряда? Или же проще/правильнее будет умножить результат на 10^сколько-разрядов-оставить, и отбросить дробную часть?
Для кроссплатформенной работы с разделяемыми библиотеками. Много использую boost, а таскать с собой кусок Qt-обёртки разделяемых библиотек как то некрасиво получается.
| ← предыдущие |