Tag: C++

Compiling OGRE3D for Android

Update: 2015-02-18 – ndk version

You can now compile OGRE3D using NDK and the OGRE branch version 1.9. Ive followed the instruction in OGRE wiki for compiling for Android but got stuck several times in several areas and almost just give up. Im new to Android specially using the NDK and all of this just overwhelmed me. So this is a step by step guide Ive decided to make on how to compile OGRE for people that are like me, new to Android.

Requirements:

Continue reading

Difference of C++ operator delete and delete[]

The difference between “delete” and “delete []” is the former is used for a pointer only while the latter is used for pointers to an array. Take for example the code below:

int main( int argc, char* argv[] ) {
 //declare a pointer to an array of char named as a
 char *a = new char[64];
 //declare a pointer to a char named as b
 char *b = new char;
 
 //since a is a pointer to an array of char the use of delete[] is a must
 delete [] a;
 //for b which is only a pointer to a char use delete
 delete b;
 
 return 0;
}

if you use “delete” on a pointer to an array it will cause a memory leak, so make sure you use the correct “delete”.

5 Simple Tips In C++

Always Initialize Variables
Since C++ doesnt give variables a default value, you should initialize it to avoid problems. That is, instead of just saying:

int a;
double b;

You should instead:

int a = 0;
double b = 0.0

Always Use Smart Pointers
Smart pointers were made to make your life easier, so why not use it? You can use boost or the one from TR1. Also smart pointers are now included in C++11.

Dont use “using namespace” in a global scope
Frankly speaking I dont really use “using namespace” even on a local scope. Namespace was made to avoid name conflicts so why take them out of their namespace and transfer them into the global space? If you really are feeling lazy to type lengthy namespaces like the one from Boost you should just use an alias:

namespace foo3 = foo1::foo2::foo3;

Use “const” Modifier
“const” will convey to the user that you dont have an intention to alter any data member or function arguments. This can also prevent some of your teammates to create codes that can affect data inside it in the future. Think of it like a contract that any parameters with const will not be changed.

Use assert() For Debugging
assert() is a handy macro for debugging. It is also easy to remove once your building for release, just define “NDEBUG”. Some do prefer unit testing but if youre maintaining a project that was made earlier by another person that doesnt have a unit test ready . Then adding asserts for the new added codes is not as difficult as making unit tests for it.20

C++ Boost Smart Pointers

C++ Boost Smart Pointers, these are template classes that implements a garbage collection system in C++, isnt that pretty neat? Now this means that you dont need to bother remembering to free all those pointers that you created because these templates will be the one making sure they are freed. You can download Boost library from their website download page.

These are the different templates for boost smart pointers:

  • scoped_ptr
    The same with std::auto_ptr that is noncopyable
  • scoped_array
    The same with std::auto_ptr that is noncopyable but for arrays, pointer created using new[]
  • shared_ptr
    Pointers can be shared with this.
  • shared_array
    Same as shared_ptr but for arrays
  • intrusive_ptr
    these templates will not release the pointers but will call functions when its constructor and destructor will be called

scoped_ptr and scoped_array
As what their name suggests these templates are used for encapsulating pointers that will only live for the current scope. This is also much like std::auto_ptr in which they are also not copyable. Example usage

void foo( void ) {
 boost::scoped_ptr< int > i1(new int);
 *i1 = 5;
 if ( *i1 == 5 ) {
 boost::scoped_ptr< int > i2( new int );
 *i2 = 5;
 //i2 will only live up to here.
 //scoped pointer will automatically release the memory for i2
 }
 //i1 will live up to here
 //scoped pointer will automatically release the memory for i1
}

shared_ptr and shared_array
These templates has a reference counter for the pointer they hold. Every copy of this will add to the reference counter and every call on the shared_ptr destructor will subtract on the reference counter. If this reference counter reach 0 the pointer will be automatically freed. Example usage

#include <iostream>
#include <boost/shared_ptr.hpp>
 
class foo {
 public:
 foo() {}
 
 boost::shared_ptr< int > num;
};
 
int main( int argc, char* argv[] ) {
 foo f;
 
 if ( argc > 1 ) {
 boost::shared_ptr< int > num( new int );
 std::cout << "current count: " << num.use_count() << std::endl;
 *num = 4;
 f.num = num; //num reference count will increase to 2
 std::cout << "current count: " << num.use_count() << std::endl;
 }
 else {
 std::cout << "Expected 1 argument";
 }
 std::cout << "current count: " << f.num.use_count() << std::endl; //reference count will be 1
 return 0;
}

weak_ptr
weak_ptr these templates will point to the pointer pointed by shared_ptr but doesnt own it. These means that what it is pointing might be already freed by shared_ptr. Example usage:

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
 
class foo {
 public:
 foo() num( new int ) {}
 
 boost::weak_ptr get_num( void ) const {
 return num;
 }
 private:
 boost::shared_ptr< int > num;
}
 
int main( int argc, char* argv[] ) {
 boost::weak_ptr< int > weak;
 {
 foo f;
 weak = f.get_num();
 if ( !weak.expired() ) {
 std::cout << *weak.lock() << std::endl;
 }
 //since f will be destroyed here and so does its member num
 //weak will reset and its expired() method will return true
 }
 std::cout << weak.expired() << std::endl;
 return 0;
}

Note: make sure you first call expired() to check if the pointer is still valid. Then call lock() this will return a shared_ptr, so that it will not be freed while you are accessing it.

intrusive_ptr
The application must have a function called intrusive_ptr_add_ref and intrusive_ptr_release with template arguments. These functions will be called by intrusive_ptr on its creation and destruction respectively. Since intrusive_ptr doenst release the pointer, intrusive_ptr_release shall be tasked of releasing the pointer once the counter reaches 0.

Example usage:

#include <iostream>
#include <boost/intrusive_ptr.hpp>
 
template <class T>
void intrusive_ptr_add_ref( T *t ) {
 t->addCount();
}
template <class T>
void intrusive_ptr_release( T *t ) {
 t->subCount();
 if ( t->count() == 0 ) {
 delete t;
 }
}
 
class foo {
 long refCount;
 public:
 foo() : refCount(0) {}
 
 void addCount(void) { refCount++; }
 void subCount(void) { refCount--; }
 long count(void) const { return refCount; }
};
 
int main( int argc, char* argv[] ){
 boost::intrusive_ptr<foo> a(new foo); //intrusive_ptr_add_ref will be called here
 return 0; //intrusive_ptr_release will be called here, that will cause to release foo
}

With these 5 template classes for memory management you can now be a pointer maniac creating pointer every where without worrie

© 2017 James Baltar

Theme by Anders NorenUp ↑