Lo que se me ocurre a mí:

Divides la cadena de 0's y 1's en grupos del mismo tamaño(puedes añadir 0's por la izquierda para que sea par):

i = 0
Para cada grupo:
total[i] = grupo << (numero de grupo * tamaño grupo)
i++

Para t en total:
t a decimal
suma += t

print suma

(<< : desplazamiento a la izquierda)

si es tan grande, tienes que tener en cuenta un acarreo, fíjate que después pones "tan grande como permita la ram"...

si agrupas de 4*N bytes debes expresar en bcd no en binario... y la solucion seria como el caso de base 16. Solo que el numero tiene que estar bien codificado, es decir que un grupo de los 4 bits no puede ser mayor que 9 = 1001

saludos

m__x_ : lo solucion que me propones seria ideal si la cadena de 0 y 1 fuese tan corta que la suma de las potencias de 2 se pudiesen almacenar en una varible entera estandar, es decir la variable "suma" que pudiese ser un long o un long long. Pero el caso es que cuando la cadena de 0 y 1 sea muy extensa entonces la variable suma se desbordara. Precisamente lo que he propuesto es representar numeros enteros positivos que sean mas grandes que los tipos standar de C/C++. Muchas gracias por tu respuesta, si se te ocurre algo mas lo estare esperando

damian_sima : lo del bcd estaria genial si lo que quisiera es tratar a estos numeros grandes como cadenas de caracteres, en este caso el problema de expresar el numero en base decimal fuera trivial, en consequencia las operaciones de suma resta y multiplicacion las tendria que hacer "pensando en decimal" lo que no seria muy eficiente, usar bcd solo supone un ahorro de memoria en comparacion a otras formas de representar los digitos o simbolos del sistema decimal, por ejemplo es mas eficiente que representar cada digito como un char.
Tal vez me exprese mal y esta un poco confusa mi pregunta, pero cuando yo digo que quiero expresar el numero como una cadena de N unsigned, no me refiero a que cada unsigned me represente un digito del 0 al 9, y la sequencia de estos numeros sea el numero en si. En este caso, mi numero es la sequencia de ceros y unos de cada elemento puestos uno de tras el otro (bueno no tan asi), por ejemplo la operacion de sumar dos numeros este tipo (a y b) es sencilla, primero sumo a[0] + b[0] lo que dara un valor unsigned "suma_parcial", luego si "suma_parcial < a[0]" (o que b[0]) es que se desbordo la capacidad de la variable "suma_parcial", por lo tanto tengo un acarreo que debo sumarle al valor "a[1] + b[1]", y asi sucesivamente, hasta haber sumado todos los elementos. Muchas gracias por tu tiempo, y bueno si tienes otra idea, pues para aca.

Según expresas, ya sabes como convertir binario a decimal (pareciera que esto solucionaría el problema), y en tu otro hilo (enteros largos [Solucionado]) ya obtuviste respuesta a un decimal tan grande como permita la memoria de la máquina, entonces puedes dar este hilo como solucionado también, y hacerlo como ya sabes.

Nota: Por muy grande que sea un número, estoy casi seguro que el "BigInt" consumirá mucho menos memoria que el mismo número en una cadena de caracteres, así que no temas desbordar el "BigInt".

---

Una solución más elegante sería crear una clase (quizás que herede de BigInt) que sea:
1- Capaz de leer un número Binario, Decimal, Octal, o Hexadecimal, y convertirlo (internamente) a BigInt.
2- Capaz de generar una cadena de caracteres representando dicho número en Binario, Decimal, Octal, Hexadecimal, etc.
3- ....

De forma que fuera posible:
BigInt x("01010001101");
BigInt x("10A5236EF5A");
cout << x.toHex();
cout << x.toBin();
String str = x.toBin();

x-cyber : lo de la clase BigInt esta muy bien, incluso la he usado ya para algunas cosas, por cierto gracias nuevamente por darme ese link. Lo que pasa es que queria hacer mi propia implementacion, y la verdad se me hace un poco dificil entender el algoritmo que ellos usan, sobre todo porque no tengo ni la mas minima idea de lo que estan haciendo. Pero tienes razon, este tema debe ser cerrado............ ademas ya encontre una forma de hacerlo, pero bueno tengo que probarla porque es una idea que elabore a lapiz y papel.

Saludos
Roberto