Macro for auto destroy heap objects - c++

Question

This is not the actual code what I'm working. but this code can be used to explain my problem in clear.
I have a function called "OnCallFunction" with some new'd objects as inputs that should be deleted inside the "OnCallFunction". In each and every point i should return, i need to add the deletion code there. I think this is not the correct way of doing this. In this way this should be remembered and put in each return which will be done in future as well. If the code is not simple as below, I may forget to insert the deletion part as well.
#include <iostream>
#include <stdlib.h>
using namespace std;
class Student
{
public:
Student(){}
~Student(){}
int GetID(){return rand();}
};
int OnCallFunction(Student* pStudent)
{
int iValue = pStudent->GetID();
if (iValue == 5)
{
delete pStudent;
return 90;
}
if (iValue == 67)
{
delete pStudent;
return 8709;
}
if (iValue == 234)
{
delete pStudent;
return 78;
}
if (iValue == 343)
{
delete pStudent;
return 9832;
}
if (iValue == 678)
{
delete pStudent;
return 876;
}
delete pStudent;
return -1;
};
int main(int argc, const char** argv)
{
Student* pStudent = new Student();
OnCallFunction(pStudent);
};
So, I played around and developed a macro for auto destroy the heap objects.
This is the modified code using the macro (AUTO_DESTROY)
#include <iostream>
#include <stdlib.h>
using namespace std;
#define AUTO_DESTROY(ClassType, Variable, DeleteStatement)\
class AD##ClassType##Variable\
{\
public:\
AD##ClassType##Variable(ClassType* pData) {Variable=pData;};\
~AD##ClassType##Variable() {DeleteStatement;};\
private:\
ClassType* Variable;\
};\
AD##ClassType##Variable oAD##ClassType##Variable(Variable)
class Student
{
public:
Student(){}
~Student(){}
int GetID(){return rand();}
};
int OnCallFunction(Student* pStudent)
{
AUTO_DESTROY(Student, pStudent, delete pStudent);
int iValue = pStudent->GetID();
if (iValue == 5)
{
return 90;
}
if (iValue == 67)
{
return 8709;
}
if (iValue == 234)
{
return 78;
}
if (iValue == 343)
{
return 9832;
}
if (iValue == 678)
{
return 876;
}
return -1;
};
int main(int argc, const char** argv)
{
Student* pStudent = new Student();
OnCallFunction(pStudent);
};
Now my questions are,
1) Does this has any performance/maintainability/code quality impact rather than deleting in each return?
2) In this macro it creates a class inside the function. So will than cause multiple declarations if we use the same macro, same class type, same variable name in multiple cpp files? Agree that I can test it.
3) Are there any ideas or pre-built things to do this in easier way?
NB:
Please do not propose to create "Student" as a stack variable in heap or keep the function output in a variable and return only at the end. :)

Answer 1

Don't use a macro, and don't use raw pointers. Use a unique_ptr to hold the allocated object, and change your function to:
int OnCallFunction(std::unique_ptr<Student> pStudent)
{
int iValue = pStudent->GetID();
if (iValue == 5)
{
return 90;
}
if (iValue == 67)
{
return 8709;
}
if (iValue == 234)
{
return 78;
}
if (iValue == 343)
{
return 9832;
}
if (iValue == 678)
{
return 876;
}
return -1;
};
int main(int argc, const char** argv)
{
std::unique_ptr<Student> pStudent(new Student());
OnCallFunction(std::move(pStudent));
};
Proper deletion of the managed Student object will be automatically done when OnCallFunction() exits.

Answer 2

boost's scope exit has implemented the functionality you want. You can look into that implementation or use it out of the box.
Example :
#include <boost/scope_exit.hpp>
#include <cstdlib>
#include <cstdio>
#include <cassert>
int main()
{
std::FILE* f = std::fopen("example_file.txt", "w");
assert(f);
BOOST_SCOPE_EXIT(f) {
// Whatever happened in scope, this code will be
// executed and file will be correctly closed.
std::fclose(f);
} BOOST_SCOPE_EXIT_END
// Some code that may throw or return.
// ...
}
Using this functionality, you'd be practically specifying freestanding "RAII destructor actions".
Use where it makes your code clearer and cleaner and avoid when all functionality would be more easily incorporated (or already is) inside a class' destructor.