Question

I’m working on a big project for embedded systems.
The project is a library and some binaries that must be integrated into customer’s code/solution.
So, it must be as much OS/Platform independent as possible.
We’ve been working on embedded linux so far without problems. However it is possible that non linux based platforms join the fun in the near future.

To ilustrate the kind of platform we are working with, they must be capable of running demanding modules such as a Java Virtual Machine.

I’m not sure which kind of platform may show up and what kind of compilers they may offer.
So I’m a little worried about using advanced C++ futures or libraries that may cause a lot of trouble. Mainly I want to avoid the possibility of incompatibility due to that.

We are refactoring a few C++ modules of our solution. They are really tricky and smart pointers support would help a lot.
At first, I thought about making a custom smart pointer package, but it seems a little risk to me (bugs here would cause a huge headache).
So I thought about using boost’s smart pointers.

Do you guys think I’m going to have trouble in the future if I use the boost’s smart pointers?

I tried to extract the boost’s smart pointer package using bcp, however a lot of other things come along with that. something like 4Mb of code.
The extracted directories are:

config/compiler
config/stdlib
config/platform
config/abi
config/no_tr1
detail
smart_ptr
mpl (and subdirs)
preprocessor (and subdirs)
exception (and subdirs)
type_traits (and dubdirs)

That doesn’t seem very portable to me (but I may be wrong about it).

What do you guys think about it?

Thanks very much for your help.

Answer 1

Newer compilers include shared_ptr as C++11/TR1. If you have a reasonably modern compiler- which you really want to have, because of C++11- then it should not be problematic.

If you do not right now have a customer who cannot use TR1, then rock on with it. You can deal with future customers when they arrive- YAGNI applies here, and smart pointers are very important. As are C++11 features like move semantics.

However, if you were desperate, you could roll your own shared_ptr– the concept is not particularly complex.