Catch all type of assertion - c++

Question

I need a condition like:
try
{
//bug condition
}
catch()
{
//Remove file
}
That is I create one very confidential file which data cannot be viewed by third party, but when any bug occurred in code my file is deleted because I don't known exactly, where bugs occurred.
So I want to catch that bug using try and catch and want to delete that file. How can I catch any exception in C++??
That will delete file if there is a bug.
Like:
try
{
char TempArray[10];
char c = TempArray[11];
}
catch
{
cout<<"Array out of boundry";
deleteFile("Confi.txt");
}

Answer 1

A word about security: If you create a file, on hard disk, with confidential information, anyone can shut down the computer while the process is running and the file is still open, take out the hard drive and read its contents.
If the file is on the server you can do basically the same thing by pausing your process before it deletes the file.
Even if you removed the file from the filesystem, most likely it can still be read, since removing a file does not wipe its contents.
I'd recommend not to deal with confidential information until you have the needed expertise - not by learning from SO. But if you have to do it, I think the watchdog process suggested here + encryption is the way to go.

Answer 2

FIRST OF ALL:
You don't want to do that.
Exceptions are not meant for handling bugs, but run-time error conditions that make it impossible for your function to satisfy the pre-conditions of other functions it has to call, or to keep the promise of fulfilling its own post-conditions (given that the caller has satisfied the pre-conditions). See, for instance, this article by Herb Sutter.
Don't ever write anything like this:
try
{
//bug condition <== NO! Exceptions are not meant to handle bugs
}
catch()
{
//Remove file
}
But rather:
assert( /* bug condition... */ );
BACK TO THE QUESTION:
Your program has undefined behavior, and most likely it will not throw any exception at all when you do:
char TempArray[10];
char c = TempArray[11];
So catching all exceptions won't help. This is a bug, i.e. a programming error, and it is arguable whether you should handle bugs in a way that transfer controls to a buggy routine; moreover, if you are admitting the presence of bugs in your program, couldn't you just be transferring control to a buggy handler? That may make it even worse.
Bugs should be dealt with by preventing them, making use of assertions, perhaps adopting methodologies such as test-driven development, and so on.
This said, regarding a way to catch all exceptions, you can do:
try
{
// ...
}
catch (...) // <== THIS WILL CATCH ANY EXCEPTION
{
}
But using catch (...) is discouraged as a design guideline, because it easily leads to swallow error conditions that are meant to be handled and forget about them. After all, exceptions were invented exactly to prevent programmers to forget checking error codes, and catch (...) makes that so easy.
For a catch-everything purpose, it would be better to let all of your exceptions derive from std::exception, and then do:
try
{
// ...
}
catch (std::exception& e)
{
// Do something with e...
}

Answer 3

What you want to use is RAII. In this case create class which in constructor take name of file and in destructor it delete the file. Before doing anything with the file you instantiate object of such class with appropriate name and later on if for whatever reason the function exits (cleanly or by means of exception), the file is going to be deleted.
Example code:
class FileGuard : public boost::noncopyable {
std::string filename_;
public:
FileGuard(const std::string &filename) : filename_(filename)
{}
~FileGuard()
{
::unlink(filename_);
}
}

Answer 4

Your code attempts to access data outside the defined boundaries, which is in all essence a completely valid thing to attempt. Depending on situation and compiler, your code may or may not crash with an access violation/segfault, most probably not. It will most certainly not raise an exception - in C++ exceptions are only thrown explicitly by code, not implicitly by the system, it just crashes if it goes wrong unlike higher level languages like Java and C#.
The catch(...) syntax will catch every possible exception, but this is not applicable in this situation.

Answer 5

As the other answers alluded to, you cannot correctly solve this problem with native, standard c++. Infact, trying to do anything once undefined behaviour has occurred is normally a really bad thing. If you do not know the state your app is in, how can you possibly and safetly run code? Just fail fast.
The proper way to solve your problem is to have another, separate 'watchdog' process performing your clean up. Its pretty simple - just have the watchdog process constantly monitor for the existance of the file. When it pops into existence the watchdog process should delete it. This delete will pend until the last reference to the file exists and then it will perform the deletion [on *nix OS's it will rename the file to a temporary place, on Win systems it will just wait until the file is unreferenced]. Once the main program is finished with the file - either through normal means or crashing or whatever, the OS will delete the file for you correctly.

Answer 6

If you want to make sure your 'private' file is always removed, how about a 'wrapper' program.
Create a new application that runs your protected application and then waits for it to terminate. When it terminates (however that is, crash or clean exit), delete your private file then exit.
Instead of running your application, run the wrapper.
int main(void)
{
int processId = exec("your protected app");
WaitForProcessExit(processId);
_unlink("protectedfile.bin");
return 0;
}

Answer 7

C++ allows you to work directly with the memory and is partly C compatible. The syntax you are trying to use:
char some_array[10];
Is kind of C syntax, not C++ and
char c = some_array[11];
is raw access to memory. This is unexpected behavior. That means that no one will tell you what is going to happen. Maybe you just get wrong character and maybe you program will be killed by OS. Or the moon will fall on the Earth. =)
If you want high level features - use pure C++. Look at standard library instead of "C" arrays. You can use std::vector with at (size_type n) method to get out_of_range exception - just like you need.