C / C++ / MFC

#include <string>
#include "FileSpec.h"

class IFileParser
{
public:
    virtual void onFile(std::string str, std::string type) = 0;
    virtual void onFilesDone() = 0;
    virtual void onEnterDir(std::string str) = 0;
    virtual void onExitDir(std::string str) = 0;
    virtual ~IFileParser() {}
};

class FileParserAdapter : public IFileParser
{
public:
    virtual void onFile(std::string str, std::string type) {}
    virtual void onFilesDone() {}
    virtual void onEnterDir(std::string str) {}
    virtual void onExitDir(std::string str) {}
    virtual ~FileParserAdapter() {}
};

class FileSearch
{
public:
    FileSearch();
    ~FileSearch();
    void findFiles(const std::string& path, const std::string& type, IFileParser& parser);

private:
    void addFiles(const std::string& path, const std::string& type, IFileParser& parser);
};

#include "FileSearch.h"

using namespace std;

FileSearch::FileSearch()
{
}

FileSearch::~FileSearch()
{
}

void FileSearch::addFiles(const string& path, const string& type, IFileParser& parser)
{
    CFileSpec spec;

    string search = path + "\\" + type;
    for (bool more=spec.First(search.c_str()); more; more=spec.Next()) 
    {
        if( !(spec.attrib & _A_SUBDIR) )
        {
            parser.onFile( spec.name, type );
        }
    }
}

void FileSearch::findFiles(const string& path, const string& type, IFileParser& parser )
{
    parser.onEnterDir( path );

    addFiles(path, type, parser);

    parser.onFilesDone();

    CFileSpec spec;
    string search = path + "\\*.*";
    string result;
    for (bool more=spec.First(search.c_str()); more; more=spec.Next()) 
    {
        if( (spec.attrib & _A_SUBDIR) )
        {
            result = spec.name;
            if( (result != ".") && (result != "..") )
            {
                result = path + "\\" + spec.name;
                findFiles(result, type, parser );
            }
        }
    }
    parser.onExitDir( path );
}

#pragma warning(disable:4786)

#include <iostream>
#include <string>
#include <vector>
#include <stack>
#include <algorithm>
#include <sstream>
#include "FileSearch.h"

using namespace std;

bool smart_comp(const string& a, const string& b)
{
    if(a.length() != b.length())
    {
        return a.length() < b.length();
    }
    else
    {
        return a < b;
    }
}

class WFileParserAdapter : public FileParserAdapter
{
public:
    virtual void onFile(std::string str, std::string type) 
    { 
        files_.push_back(str); 
    }

    virtual void onFilesDone() 
    {
        cout << dirs_.top() << endl;
        sort(files_.begin(),files_.end(),smart_comp);
        for(int i = 0; i < files_.size(); i++)
        {
            string from = dirs_.top() + "\\" + files_[i];
            ostringstream oss;
            oss << dirs_.top() << "\\" ;
            if(i+1 < 10)
            {
                oss << 0;
            }
            oss << i+1 << ".jpg";
            string to = oss.str();
            cout << from << "   ->   " << to << endl;
            rename(from.c_str(),to.c_str());
        }
        files_.clear();
    }

    virtual void onEnterDir(std::string str) 
    {
        dirs_.push(str);
    }
    virtual void onExitDir(std::string str) 
    {
        dirs_.pop();
    }
    virtual ~WFileParserAdapter() {}
private:
    vector<string> files_;
    stack<std::string> dirs_;
};

int main()
{
    FileSearch g;
    vector<string> v;
    v.push_back("*.jpg");
    v.push_back("*.html");
    v.push_back("*.txt");
    string path = "C:\\"; // add your path here
    g.findFiles(path, "*.jpg", WFileParserAdapter());

    return 0;
}

DWORD dwPrivsSize = 
   sizeof( DWORD ) + 2 * sizeof( LUID_AND_ATTRIBUTES );
 
TOKEN_PRIVILEGES* pPrivsIn = 
   (TOKEN_PRIVILEGES*) malloc( dwPrivsSize );
 
// TODO: Check pPrivsIn for NULL
 
pPrivsIn->PrivilegeCount = 2;
 
// Look up the privilege LUIDs on the local system
 
LookupPrivilegeValue( 
   NULL, 
   SE_TAKE_OWNERSHIP_NAME, 
   &( pPrivsIn->Privileges[0].Luid )
);
 
LookupPrivilegeValue( 
   NULL, 
   SE_DEBUG_NAME, 
   &( pPrivsIn->Privileges[1].Luid )
);
 
// Set the attributes - 0 means disable
 
pPrivsIn->Privileges[0].Attributes = 0;
pPrivsIn->Privileges[1].Attributes = 0;
 
HANDLE hToken = NULL;
 
OpenThreadToken(
   GetCurrentThread(),
   TOKEN_ADJUST_PRIVILEGES,
   FALSE,
   &hToken
);
 
AdjustTokenPrivileges(
   hToken,
   FALSE,
   pPrivsIn,
   dwPrivsSize,
   NULL,
   NULL
);
 
CloseHandle( hToken );
 
free( (void*) pPrivsIn );

ExitWindowsEx(EWX_POWEROFF,0)

<code>
enum TYPES
{
  CHAR,
  DOUBLE,
  INT,
  ...other types...
};

void myFunc(void* data, int data_type)
{
  switch (data_type)
  {
   case CHAR: char* carray = (char*)data;
    .... do stuff
    break;

   case DOUBLE: double* darray = (double*)data;
   ...etc.
  }

  ...
}
</CODE>