La problemática de almacenamiento es despreciable... lee bien lo que se quiere.


Dulces Lunas!¡.

* No digas imposible por que si se puede.
* Tu código Tiene Bastantes errores... revisa-lo con el mio y veras la diferencia... (cuando llega a por ejemplo AAAAZ se devuelve a AAAAA)...
http://foro.elhacker.net/programacion_cc/como_hacer_un_generador-t366597.0.html;msg1765302#msg1765302
* En el tema de los núcleos se tendría que separar La cadena en N donde N es la cantidad de núcleos, a su vez crear N hilos... esto es un poco mas tedioso por mi parte lo dejo asi.

Bueno mi código ya funciona al 100%

Dulces Lunas!¡.

Queda claro que la cantidad esta dada por 26^N y debido a esto le hice una modificación a mi código...

http://foro.elhacker.net/programacion_cc/como_hacer_un_generador-t366597.0.html;msg1765220#msg1765220

 
#include <iostream>
#include <cmath>
using namespace std;
 
inline string &addWord(string &text) {
    string::reverse_iterator it = text.rbegin();
    for (; it != text.rend(); it++) {
        ++(*it);
        if (tolower(*it) >= 'a' && tolower(*it) <= 'z') break;
        (*it) = (islower(*it))? 'a': 'A';
    }
    return text;
}
 
size_t addAllWord(string text, void (*callback)(string&, bool&) = NULL) {
    bool cancel = false;
    register size_t i = 0, lim = pow(26, text.size());
    if (!callback) return lim;
    for (;(i < lim) && (cancel ==false); i++) {
        callback(addWord(text), cancel);
    }
    return i;
}
 
void showWords(string& text, bool& cancel) {
    cout << text << endl;
}
 
int main() {
    string text = "ZZZx";
    cout << addAllWord(text, showWords) << endl;
    cin.get();
    return 0;
}
 
 

.
La cantidad de combinaciones desde A-Z (sin contar la Ñ) en una cadena de 10 segun este algoritmo es de (26 ^ 10) = 141167095653376 combinaciones posibles desde AAAAAAAAAA hasta ZZZZZZZZZZ.

Dulces Lunas!¡.

(Hablando de VB.NET)
Amm no me acuerdo muy bien pero la clase string tiene la funcion split...

TextBox2.Text.Split(",")[0]
TextBox2.Text.Split(",")[1]
TextBox2.Text.Split(",")[2]

* si estas en VB .NET en lugar de usar CInt() usa Convert.ToInt32() o Convert.ToInt64() para transformar una string en un integer (32/64)
* si vas a redondear usa Math.Round() mas no las funciones anteriores...

Dulces Lunas!¡.

Yo aprendí aquí:

http://www.zator.com/Cpp/E_Ce.htm

P.D.: No es que sean poco comunes es que solo mezclamos C con C++ en si static_cast, reinterpret_cast, const_cast, etc  son simples Cast de C pero especialmente para C++...

Dulces Lunas!¡.

.
En C++ se usa...

 
class hola
{
    public:
        //hola();
        //virtual ~hola() = 0;
    protected:
    private:
};
 
int main() {
    hola clase;
    void *ptr = static_cast<void*>(&clase); // caso Normal (cuando marque error usar el caso extremo).
    //void *ptr = reinterpret_cast<void*>(&clase); // caso Extremo (Tener cuidado al usar).
    return 0;
}
 
 

Dulces Lunas!¡.

.
ammm sabes que latencia ofrece una memoria primaria a una secundaria?, es demasiada la diferencia... jamas dije que es malo leer de trozos en trozos, es bueno en algunos casos, pero para saber cuanto buffer debemos establecer hay que hacer algunos cálculos entre el tiempo de procesamiento y la carga de los datos... un ejemplo de esto es por ejemplo Nero, Alcohol, etc... crear un buffer de por lo menos 256 megas o arriba de 100 megas no recuerdo cual es el mínimo, para no interrumpir la escritura de un datos en un disco, mientras en segundo plano se cargan los datos...

 *En el tema de la PC, tengo dos PC es "Intel Pentium 4 + 256 megas con un HDD de 80 Gigas a 7200 RPM" y la otra es una "AMD Phenom II X4 965 Black Edition + 16 Gigas de RAM DDR3 con un HDD de 1 Tera a 7200 RPM", y la verdad NO noto diferencia entre aplicaciones creadas en VB6 (por el tema de los hilos), en pocas palabras no veo la forma en que vb6 tenga un gran impacto en la velocidad entre ambas PC'S, lo que si te puedo asegurar es que para leer trozos a trozos los datos y a su vez procesarlos si el proceso es muy rapido con es este el caso es mejor cargar el archivo prácticamente con buffers de 50 a 100 megas o lo que se requiera (considerando la pequeña latencia perjudicial de lectura), en caso contrario si el procesamiento es LEEENTO y complejo seria bueno cargar entre 1 a 10 megas o lo que se requiera.

Dulces Lunas!¡.

.
Intenta con esto...

 
#include <iostream>
#include <cstdio>
 
using namespace std;
 
inline int lenNum(unsigned int num) {
    char buff[20];
    return sprintf(buff, "%d", num);
}
 
inline unsigned long long joinVector(unsigned int *vector, size_t size) {
    register int mul = 1;
    register unsigned long long ret = 0;
    while(size--) {
        ret += (vector[size] * mul);
        if (size)
            for (register unsigned int i = 1, ln = lenNum(vector[size]); i <= ln; i++)
                mul *= 10;
    }
    return ret;
}
 
int main() {
    unsigned int vector1[5] = {5, 978, 6, 4, 9}, vector2[5] = {65, 9, 12, 66, 45};
    cout << joinVector(vector1, 5) + joinVector(vector2, 5) << endl;
    cin.get();
    return 0;
}
 
 

   005978649
+ 659126645
______________
665105294


Dulces Lunas!¡.

aaaaa ya entendí... es simple... dame unos minutos...

Dulces Lunas!¡.