Просмотр папок и подпапок с помощью 4 процессов

[Yoh]

Здравствуйте. Стоит задача пройтись по папкам с помощью 4 копий одной и той же программы. Пока что результаты прохода пробую писать в разные файлы. Программа падает, помогите пожалуйста понять, в чем дело. В с++ полный новичек, поэтому прошу сильно не бить

#define _CRT_SECURE_NO_WARNINGS

#define BOOST_FILESYSTEM_VERSION 3

//мои константы
#define BUF_SIZE					8000
#define SHARED_MEMORY_BLOCK_NAME	"Directory_list"

#include "MemoryManager.h"
#include <fstream>

namespace fs = boost::filesystem;

int main(int argc, char* argv[])
{
	fs::path p/*(fs::current_path())*/;

	//если основной процесс
	if (argc > 1)
	{
		char programName[] = "C:\\Users\\Phanthom\\Documents\\Visual Studio 2012\\Projects\\try349\\Debug\\try349.exe";

		HANDLE secondProcess;
		HANDLE thirdProcess;
		HANDLE fourthProcess;

		std::string firstPath = argv[1];// + '\n';
		firstPath += '\n';
		if(!CreateNewProcess(secondProcess, 2, programName))
		{
			std::cout << "Error creating process 2" << std::endl;
		}
		if(!CreateNewProcess(thirdProcess, 4, programName))
		{
			std::cout << "Error creating process 3" << std::endl;
		}
		if(!CreateNewProcess(fourthProcess, 8, programName))
		{
			std::cout << "Error creating process 4" << std::endl;
		}
		hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, BUF_SIZE, SHARED_MEMORY_BLOCK_NAME);
		mutex = CreateMutex(NULL, true, "MyMutex");
		WaitForSingleObject(mutex, INFINITE);
		if (hMapFile != INVALID_HANDLE_VALUE)
		{
			void* buf = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, BUF_SIZE);
			if (buf)
			{
				strcpy((char*)buf, firstPath.c_str());
				UnmapViewOfFile(buf);
			}
		}
		ReleaseMutex(mutex);
		Sleep(500);
	}
	
	hMapFile = OpenFileMapping( FILE_MAP_ALL_ACCESS, FALSE, SHARED_MEMORY_BLOCK_NAME);
	mutex = OpenMutex(SYNCHRONIZE, false, "MyMutex");
	std::ofstream F;
	if (!fs::exists("C:\\1.txt"))
	{
		F.open("C:\\1.txt");
	}
	else if (!fs::exists("C:\\2.txt"))
	{
		F.open("C:\\2.txt");
	}
	else if (!fs::exists("C:\\3.txt"))
	{
		F.open("C:\\3.txt");
	}
	else if (!fs::exists("C:\\4.txt"))
	{
		F.open("C:\\4.txt");
	}

	CMemoryManager MyManager(hMapFile);

	while(true)
	{
		std::string currentPath;
		WaitForSingleObject(mutex, INFINITE);
		currentPath = MyManager.ReadFromMemory();
		ReleaseMutex(mutex);
		if(currentPath.empty())
		{
			Sleep(1000);
			WaitForSingleObject(mutex, INFINITE);
			currentPath = MyManager.ReadFromMemory();
			ReleaseMutex(mutex);
			if(currentPath.empty())
			{
				break;
			}
		}	
		p = fs::system_complete(TrimEnd(currentPath));
		WaitForSingleObject(mutex, INFINITE);
		if(!MyManager.WriteInMemory(TrimBegin(currentPath)))
		{
			F << "Error on writing" << std::endl;
		}
		ReleaseMutex(mutex);
		if (!fs::exists(p))
		{
			WaitForSingleObject(mutex, INFINITE);
			F << "\nNot found: " << p << std::endl;
			ReleaseMutex(mutex);
		}
		if (fs::is_directory(p))
		{
			ParseDirectory(p, MyManager, F, argc);
		}
	}
	F.close();
	CloseHandle(hMapFile);
	return 0;
}

void ParseDirectory(fs::path p, CMemoryManager &manager, std::ofstream &f, int argc)
{
	fs::directory_iterator end_iter;
	for (fs::directory_iterator dir_itr(p);
		dir_itr != end_iter;
		++dir_itr)
	{
		try
		{
			if (fs::is_directory(dir_itr->status()))
			{
				WaitForSingleObject(mutex, INFINITE);
				std::string temp = manager.ReadFromMemory();
				ReleaseMutex(mutex);
				temp += '\n';
				temp += dir_itr->path().string();
				WaitForSingleObject(mutex, INFINITE);
				if(!manager.WriteInMemory(temp))
				{
					f << "Error on writting" << std::endl;
				}
				ReleaseMutex(mutex);
			}
			else if (fs::is_regular_file(dir_itr->status()))
			{
				if(argc > 1)
				{
					f << dir_itr->path().filename() << "\n";
				}
				else
				{
					f << dir_itr->path().filename() << "LOOOOL" << "\n";
				}
			}
			else
			{
				f << dir_itr->path().filename() << " [other]\n";
			}
		}
		catch (const std::exception & ex)
		{
			f << dir_itr->path().filename() << " " << ex.what() << std::endl;
		}
	}
}

std::string TrimEnd(std::string const& s)
{
	size_t pos = s.find_first_of('\n');
	return
		(pos == std::string::npos)
		? s
		: s.substr(0, pos);
}

std::string TrimBegin(std::string const& s)
{
	size_t pos = s.find_first_of('\n');
	return
		(pos == std::string::npos)
		? ""
		: s.substr(pos+1, s.length());
}

bool CreateNewProcess(HANDLE &hProcess, int mask, char* s)
{
	STARTUPINFO si; 
	PROCESS_INFORMATION pi;

	ZeroMemory(&si, sizeof(STARTUPINFO)); 
	si.cb = sizeof(STARTUPINFO);

	if (!CreateProcess(NULL, s, NULL, NULL, FALSE, 
	NULL, NULL, NULL, &si, &pi))
	{
		std::cout << "The new process is not created. " << std::endl;
		return false;
	}
	hProcess = pi.hProcess;
	SetProcessAffinityMask(hProcess, mask);
	return true;
}

[Yoh]

Извините вырезал некоторые объявления.

//мои константы
#define BUF_SIZE					8000
#define SHARED_MEMORY_BLOCK_NAME	"Directory_list"


#include "boost/filesystem/operations.hpp"
#include "boost/filesystem/path.hpp"
#include "boost/progress.hpp"
#include "windows.h"
#include "MemoryManager.h"
#include <fstream>
#include <iostream>

namespace fs = boost::filesystem;

std::string TrimEnd(std::string const& s);
std::string TrimBegin(std::string const& s);
void ParseDirectory(fs::path p, CMemoryManager &manager, std::ofstream &f, int argc);
bool CreateNewProcess(HANDLE &hProcess, int mask, char* s);
HANDLE hMapFile;
HANDLE mutex;

[Yoh]

Сам разобрался. Оказывается, ошибка была в самом поиске имен. Программа падала при файлах и папках с пробелами в именах. Буду решать проблему. Извините за беспокойство