C / C++ / MFC

ntkrnlpa.exe!ExAllocatePoolWithTag+0x8ab
ntkrnlpa.exe!MmIsDriverVerifying+0xa08
ntkrnlpa.exe!MmIsDriverVerifying+0x12ea
ntkrnlpa.exe!PoShutdownBugCheck+0x32ce
ntkrnlpa.exe!KeSynchronizeExecution+0x10c
ntdll.dll!KiFastSystemCallRet
!WaitForSingleObject+0x12
!waveOutWrite+0x50c
!mci32Message+0x526
!mciSendCommandW+0x10b
!mciSendCommandW+0x48e
!mciSendStringW+0x31
!mciSendStringA+0x87

char block[3];

block[0] = 'a';block[1] = 'a';block[2] = 'a';

cout << block;

Failure is Success If we learn from it!!

#include <boost/filesystem.hpp>
namespace bf = boost::filesystem;
#include <string>
#include <iostream>
using namespace std;
string e_string = "Error";
int main()
{
	string fileName = "C:\\Downloads\\Hits from the Bow\\01 This Time You're Gonna Get it Dir.mp3";
	string destination = "c:\\downloads\\test" ;
	bf::path fileCopied(fileName);
	bf::path fileCopiedDestination (destination);
	if (!bf::exists(fileCopied) )
	{
		cerr << e_string;
	}
	 if (!bf::exists(fileCopiedDestination))
		{
		cerr << e_string;
	}
	try
	{
		bf::copy_file(fileCopied,fileCopiedDestination);
	}
	catch(std::exception e)
	{
		cout << e.what();
	}
}

/**************************************************************
* p2cComm.c
*   
* C program that implements communication between two processes  
* Program creates 2 unnamed pipes, p and q. Then it creates a 
* child process. Next, it links the parent with the child using
* the two pipes. Pipe p: Parent to Child, Pipe q: Child to Parent.
* Child receives commands from parent through Pipe p and sends 
* responses through Pipe q.
***************************************************************/  

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
 
int main(int argc, char *argv[]){ 
 
        int pid; 
        int p[2];   /* pipe "p" */ 
        int q[2];   /* pipe "q" */ 
        int a; 
        int b; 
 
        /* Create Pipe. Pipe P is used to transfer information  
        from the parent process to the child process */ 
        a = pipe(p);
        if(a == -1) 
        { 
        fprintf(stderr, "Pipe Failed.\n"); 
        return EXIT_FAILURE; 
        } 
         
        /* Create second pipe. Pipe Q is used to transfer information 
        from the child process to the parent process. */ 
        b = pipe(q); 
        if(b == -1) 
        { 
         fprintf(stderr, "Pipe Failed.\n"); 
         return EXIT_FAILURE; 
        } 
         
        /* Create child process */ 
        pid = fork(); 
 
        switch(pid){ 
         
                case -1: /* fork failed */ 
                        perror("main: fork"); 
                        exit(1); 
                
		/* Child process will execute a loop, waiting for command
		from the parent process. Child executes the command. Child
		returns a response to the parent */
		case 0: /* Child process */ 
                printf("Child process ID: %d\n", pid);
                break;
                /* do some things */ 
 
                /* Parent process will execute a loop, asking user for a one
		line command. Parent sends command to child for execution.
		Parent waits for the response of the child. Parent finally
		reports the result (displayed on screen). */
		default: /* Parent process */ 
                printf("Parent process ID: %d\n", pid);
                break;
                /* do some things */ 
         } 
        getchar();
        return 0; 
}