Как Вам такая идея:
Сделать на LOR'e архив проектов (ака SourceForge), авторами
которых будет LOR-сообщество.

Сделать то достаточно просто - upload/download, description, search, 
docs.

Думаю у многих есть програмки, скрипты или целые проекты, которыми
есть желание поделиться.

Ведь все мы за Open Source :)

Всем привет!

У меня есть задачка, но я не знаю, как лучше и правильнее её решить.
Может быть кто-нибудь наведёт на верные мысли.

Задача заключается в следующем:
Имеется некий файл, который содержит записи в определённом формате.
Есть необходимость последовательно вытаскивать из файла записи и 
обрабатывать их в программе.
Обычно записи - просто строки определённой длины.

Я хочу инкапсулировать все операции в классе, у которого 
предусмотреть метод GetRecord.

Проблема заключается в том, что хотелось бы иметь возможность 
обрабатывать файлы разного формата.
Т.е. строки могут разделяться \n или символом с кодом \002.
А может быть и ситуация, что определены последовательности начала
и конца записи (rec_begin, rec_end).

Сделать это хотелось бы следующим образом:
В конструктор класса передавать имя файла и строку с регулярным 
выражением, отвечающим шаблону записи.
Далее метод GetRecord будет просто последовательно получать записи
из ifstream'a и возвращать пользователю класса!

Т.е. должно получиться что-то вроде:
....
std::string reg_ex_1 = ...
std::string reg_ex_2 = ...
Source S1("file1.txt", reg_ex_1);
Source S2("file2.txt", reg_ex_2);
ProcessRecord1(S1.GetRecord());
ProcessRecord2(S2.GetRecord());
....

Вопрос: возможно ли реализовать подобное в C++
Причём данные хотелось бы читать непосредственно из ifstream, а не
наворачивать дополнительные буферы.
Программа должна работать по принципу
Пока есть записи
 {
   Чтение записи
   Обработка записи
 }
а не так:
Читаем все записи в буфер
Обрабатываем все записи

Файлы могут быть до 50Мб!

Всем привет!

Я собрал программу, сделал ldd my_prog и заметил, что программа
зависит от большого числа динамических библиотек.

Затем я указал g++ опцию -static и получил статический бинарник,
который ни от чего не зависит.

Возник вопрос, а можно ли сделать бинарник статическим, но при
этом чтобы от одной либы он всё же зависил динамически (не хочется 
её вкомпиливать)?

Я пишу класс обёртку вокруг boost::program_options
и столкнулся с проблемой компиляции вот этого метода:

///////////////////////////////////////////////////////////////////
// General options selector
template <class T>
void CmdLine::GetOption(const std::string& Name, T& var)
{
   if (VariablesMap_.count(Name)) var = VariablesMap_[Name].as<T>();
}
////////////////////////////////////////////////////////////////////

Ошибки следующие:
Compiling OBJ/Cmdline.oIn file included from CmdLineParse/Cmdline.hpp:46,
                 from CmdLineParse/Cmdline.cpp:7:
CmdLineParse/Cmdline.tcc: In member function `void CmdLine::GetOption(const
   std::string&, T&)':
CmdLineParse/Cmdline.tcc:7: syntax error before `>' token

Не могу понять где тут ошибка синтаксиса?!

Вроде в доке всё аналогично:
http://www.boost.org/doc/html/program_options/tutorial.html#id1246788

Всем привет!
Я написал простенькую программу:

#include <stdio.h>
int f1()
{
   printf("Entering f1\n");
   //...
   printf("Exiting f1\n");
   return 0;
    
}
 
int f2()
{
   printf("Entering f2\n");
   //...
   return f1(),printf("Exiting f2\n");  // !!!
}

int main()
{
   printf("Entering main\n");
   f2();
   printf("Exiting main\n");
}

Вывод программы следующий:
Entering main
Entering f2
Entering f1
Exiting f1
Exiting f2
Exiting main

Всё правильно!

Но вот я не очень понимаю как работает строка
return f1(),printf("Exiting f2\n");  // !!!
Разве это допустимо?
Как это выполняется, в какой последовательности?

Может результат, полученный мной, зависит от реализации?

Как через /proc или что-то ещё узнать максимально возможный объём 
памяти, поддерживаемый ОС/ядром

Честно скажу - я не поклонник Windows, точнее даже противник.
Однако в виндах мне всегда нравилась одна вещь - отладчики.

Кто бы что ни говорил, отладка в gdb - не самое приятное занятие
для человека, который видел только виндовые отладчики, а сам всю
жизнь использовал отладочную печать.

Есть ли в UNIX-like системах достойная альтернатива, которая
имеет привычную (виндовую) логику работы?

В /etc/fstab у меня прописано монтирование smaba-шары.
Среди опций указан также пароль пользователя на шару.

Однако я обнаружил интересную фичу, при выполнении команды
ps auxw | grep smb

Как и следовало ожидать я увидел название программы и все переданные
ей опции, но вместо пароля было написано xxxxxxxx!!!
Т.е. реализовано сокрытие пароля от глаз посторонних! 

Я вот подумал, как реализовать это в своих программах.

Не понимаю правда на уровне чего (ps, bash, programm) реализуется
подобное поведение.

Знает кто-нибудь ответ?

Всем привет!

Начал вот писать класс для работы с командной строкой.
За основу взял boost::program_options.

Есть у меня в программе строковые и булевые опции.
Для их хранения предусмотрены ассоциативные массивы.

Только вот не хочу я делать методы типа
GetStringOption, GetBoolOption и т.д.
Хочется написать что-то вроде шаблонного метода, приведённого
ниже, а потом вызывать:

CmdLine C(argc,argv);
const std::string s("disable_stderr");
bool b = C.GetOpt(s);
const std::string ss("cfg_f_name");
std::string name = C.GetOpt(ss);

Правда вот для C++ подобные фокусы неправильны.
Как я понимаю без явной специализации не обойтись:
bool b = C.GetOpt<bool>(s);
std::string name = C.GetOpt<std::string>(ss);

Вообщем задача понятна : вызывать нужный метод в зависимости от
типа значения слева без явного указания этого типа.
Как это реализовать в C++?

Кусочек класса приведён ниже
/*
  \class CmdLine
  \brief Class for encapsulate all command line operations
*/
class CmdLine
{
   public:
     /// Constructor
     CmdLine(int argc, char** argv);
     /// Destructor
     ~CmdLine();
     template <class T>
     T GetOpt(const std::string& OptionName) const
     {
        // Do anything 
     }
   private:
     /// Map for string options, e.g. Script File Name
     std::map<std::string,std::string> StringOptions_;
     /// Map for string options, e.g. Disable StdErr Output
     std::map<std::string,bool> BoolOptions_;
     /// Options Description
     po::options_description Description_;
};

Есть задача:
Программа обрабатывает текстовые данные (по одному файлу за запуск).
Для корректной обработки файла N необходимо иметь 
информацию об обработке предыдущих N-1 файлов.

Информация может иметь любую структуру (например одна строка).
Каждой единице информации в соответствие поставлен некий ключ.

Если при обработке файла N будет обнаружен ключ, то по этому ключу должен происходить быстрый поиск и выборка данных из некого хранилища.

Мне на ум пришла лишь идея с файловой БД, но скорее всего это не
лучший вариант.
Информация должна обладать живучестью файловой системы (т.е. 
организовать хранилище в Shared Memory невозможно)

Не хотелось бы использовать реальные БД (Oracle, MySql, PS-SQL)
для достаточно простой задачи.

Имеются ли какие-нибудь средства для решения данной задачи?