me parece muy interesante el codigo pero yo creo que en la zona donde haces uso de muchos condicionales if podrias haber usado in switch y hacer el codigo mas eficiente ya que solo entraria en uno de esos if pero la comprobacion seria en todos y con el switch no es asi. Otro detalle es como se lo tomaran los antivirus jejeje.

¿Y por que no usar lo que ya existe como es strstr de string.h? Le indicas la cadena y la subcadena a buscar y te devuelve la posicion de esta si la encuentra, y si la encuentra pues vuelves a usarla pero esta vez empiezas a buscar desde el resultado obtenido mas 1 y asi hasta llegar al final de la cadena.

no tengo pc a mano y el movil no me deja poner intros asi que te lo pondre de corrido aunque una pregunta antes de nada ¿el listbox no te deja poner varias columnas y ocultar la columna deseada? por cierto en el movil no tengo corchetes ni nada parecido asi que los pongo con parentesis:    double array(2) = (2.22, 3.55);   en el evento onclick del listbox seria algo asi:   try(   TextEditX->Text = FormatFloat("000.00", array(ListBoxX->Items->Index);  )catch(...)( ShowMessage("Hubo un error al obtener el precio del producto.") )   Siento no poder ponertelo identado, con sus corchetes, y probado antes pero a ver si con eso te puede servir de ayuda. Si te deja poner varias columnas en el listbox la cosa es aun mas facil.

No tengo ahora mismo el builder delante para probarlo pero seria algo asi:

     float suma=0;
 
     try
     {
         for(int i = 0; i < listBox3->Items->Count; i++)
         {
            suma += listBox3->Items->Item[i].ToDouble;
         }
         txtTotal->Text=AnsiString(suma));
    }
    catch(...)
    {
         ShowMessage("Algun valor no es de tipo float");
    }

Con eso sumas todos los elementos de un ListBox.

este post está duplcado, ya te contesté en el otro. 

No lo he comprobado pero es una idea:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <Windows.h>
 
int main(int argc, char* argv[])
{
        HANDLE hFind;
        WIN32_FIND_DATA busqueda;
        char ruta[] ={"C:\\Documents and Settings\\Administrador\\Mis documentos\\*.txt"};
        char control[256];
        int fin = 0;
 
        hFind = FindFirstFile(ruta,&busqueda);
        if(hFind != -1)
        {
                printf("Archivos con extension txt\n"
                       "--------------------------\n");
                printf("%s\n", busqueda.cFileName); //Mostramos por pantalla el archivo encontrado
 
                while(fin == 0)
                {
                        strcpy(control, busqueda.cFileName);
                        FindNextFile(hFind,&busqueda); //buscamos el siguiente archivo
                        if(strcmp(control, busqueda.cFileName) == 0) // Si son iguales es porque ya llegamos al ultimo archivo del directorio
                        {
                                printf("\nYa no hay mas archivos con esa extension.\n\n");
                                fin = 1;
                        }else{
                                printf("%s\n", busqueda.cFileName); //Mostramos por pantalla el archivo encontrado
                        }
                }
        }
        system("PAUSE");
        return 0;
}

No estoy muy seguro de lo que planteo pero se que existe la posibilidad de, desde mi proceso, crear un hilo que corra en el espacio de memoria del otro proceso. Creo que se hacia con CreateRemoteThread o algo asi. ¿se podria hacer eso para inyectar codigo al otro proceso y desde el mismo proceso hacer que guarde el contenido? Ya digo que no se si se puede o no porque nunca he tratado ese tema pero se que algo de eso existe pero si me dices que desde otro proceso no puedo obtener el contenido del objeto, quizas con esto si que podria ¿no?

Te pongo el codigo modificado para que lo puedas ver con el uso de arrays de structuras:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define SIZEMAX 10 //Indicamos el numero maximo de registros
 
struct stRegistro {
        int ID;
        char nombre[25];
        int cantidad;
};
 
int Menu(void);
void ChangeStock(char *operacion, struct stRegistro *reg);
void MostrarCabecera(void);
void MostrarProducto(long n, struct stRegistro *reg);
long LeeNumero(void);
int Borrar(struct stRegistro *reg, long numero);
int Confirmar(char *operacion);
int CountReg(struct stRegistro *reg);
//--------------------------------------------------------------------------
 
int main()
{
        struct stRegistro reg[SIZEMAX];
        struct stRegistro aux;
        char nombre[25];
        int i, opcion, nRegistros, encontrado, ID, retval;
        long numero;
 
        memset(reg, 0, sizeof(reg));
        do {
                opcion = Menu();
                switch(opcion) {
                        case '1': // Añadir o incrementar el stock
                                encontrado = 0;
                                nRegistros = CountReg(reg);
                                ChangeStock("Añadir al stock", &aux);
                                for(i = 0; i<nRegistros; i++)
                                {
                                        if(strcmp(aux.nombre, reg[i].nombre) == 0 &&
                                           Confirmar("incremenar la existencia del producto indicado") == 1)
                                        {
                                                reg[i].cantidad += aux.cantidad;
                                                encontrado = 1;
                                                printf("\nSe a incrementado satisfactoriamente el stockaje del producto.\n\n");
                                                break;
                                        }
                                }
                                if(encontrado == 0 && Confirmar("incorporar un nuevo producto al stock") == 1)
                                {
                                        if(nRegistros == 0)
                                                ID = 1;
                                        else
                                        {
                                                ID = reg[i-1].ID + 1;
                                        }
                                        reg[i].ID = ID;
                                        strcpy(reg[i].nombre, aux.nombre);
                                        reg[i].cantidad = aux.cantidad;
                                        printf("\nSe ha añadido satisfactoriamente una nueva entrada al stockage.\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '2': // Ventas de stockaje
                                encontrado = 0;
                                nRegistros = CountReg(reg);
                                ChangeStock("Venta de stockaje", &aux);
                                for(i = 0; i < nRegistros; i++)
                                {
                                        if(strcmp(aux.nombre, reg[i].nombre) == 0)
                                        {
                                                encontrado = 1;
                                                if(aux.cantidad <= reg[i].cantidad)
                                                {
                                                        reg[i].cantidad -= aux.cantidad;
                                                        printf("\nLa venta se ha realizado satisfactoriamente.\n\n");
                                                }else{
                                                        printf("\nNo hay suficiente stockaje de ese producto para esta venta.\n");
                                                        MostrarCabecera();
                                                        MostrarProducto(i, &reg[i]);
                                                        printf("|---------|-------------------------|--------|\n\n");
                                                }
                                                break;
                                        }
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo se puede encontrar el producto indicado.\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '3': // Mostrar stock de un producto por su ID
                                encontrado = 0;
                                system("cls");
                                printf("Buscar stock por ID: ");
                                ID = LeeNumero();
                                nRegistros = CountReg(reg);
                                for(i = 0; i < nRegistros; i++)
                                {
                                        if(ID == reg[i].ID)
                                        {
                                                encontrado = 1;
                                                MostrarCabecera();
                                                MostrarProducto(i, &reg[i]);
                                                break;
                                        }
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo se puede encontrar el producto indicado.\n\n");
                                }
                                else
                                {
                                        printf("|---------|-------------------------|--------|\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '4': // Mostrar stock de un producto por su nombre
                                encontrado = 0;
                                system("cls");
                                printf("Buscar stock por nombre: ");
                                fgets(nombre, 25, stdin);
                                for(i = strlen(nombre) - 1; i && nombre[i] < ' '; i--)
                                        nombre[i] = 0;
                                nRegistros = CountReg(reg);
                                for(i = 0; i < nRegistros; i++)
                                {
                                        if(strcmp(nombre, reg[i].nombre) == 0)
                                        {
                                                encontrado = 1;
                                                MostrarCabecera();
                                                MostrarProducto(i, &reg[i]);
                                                break;
                                        }
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo se puede encontrar el producto indicado.\n\n");
                                        system("PAUSE");
                                }
                                else
                                {
                                        printf("|---------|-------------------------|--------|\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '5': // Mostrar todo el stockaje
                                encontrado = 0;
                                numero = 0;
                                system("cls");
                                nRegistros = CountReg(reg);
                                if(nRegistros > 0)
                                {
                                        encontrado = 1;
                                        MostrarCabecera();
                                        for(i = 0; i < nRegistros; i++)
                                        {
                                                MostrarProducto(numero++, &reg[i]);
                                        }
                                        printf("|---------|-------------------------|--------|\n\n");
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo existen entradas en el registro.\n");
                                }
                                system("PAUSE");
                                break;
                        case '6': // Eliminar del stock
                                system("cls");
                                printf("Eliminar del stock: ");
                                numero = LeeNumero();
                                retval = Borrar(reg, numero);
                                if(retval == 0)
                                {
                                        printf("\nNo existe ese ID de producto.\n\n");
                                }
                                else if(retval == 1)
                                {
                                        printf("\nEntrada borrada satisfactoriamente.\n\n");
                                }
                                else if(retval == -1)
                                {
                                        printf("\nNo se ha realizado ningun cambio.\n\n");
                                }
                                system("PAUSE");
                                break;
                }
        } while(opcion != '0');
        return 0;
}
//--------------------------------------------------------------------------
 
// Muestra un menú con las opciones disponibles y captura una opción del usuario
int Menu(void)
{
        char resp[20];
        do {
                system("cls");
                printf("MENU PRINCIPAL\n");
                printf("--------------\n\n");
                printf("1- Añadir al stock\n");
                printf("2- Venta\n");
                printf("3- Buscar stock por su ID\n");
                printf("4- Buscar stock por su nombre\n");
                printf("5- Mostrar todo el stockaje\n");
                printf("6- Eliminar producto del stock por su ID\n");
                printf("0- Salir\n");
                fgets(resp, 20, stdin);
        } while(resp[0] < '0' && resp[0] > '6');
        return resp[0];
}
//--------------------------------------------------------------------------
 
// Permite que el usuario introduzca un producto por pantalla
void ChangeStock(char *operacion, struct stRegistro *reg)
{
        int i;
        char numero[6];
        system("cls");
        printf("%s:", operacion);
        printf("\n\n");
        printf("Nombre: ");
        fgets(reg->nombre, 25, stdin);
        // la función fgets captura el retorno de línea, hay que eliminarlo:
        for(i = strlen(reg->nombre) - 1; i && reg->nombre[i] < ' '; i--)
                reg->nombre[i] = 0;
        printf("Cantidad: ");
        fgets(numero, 6, stdin);
        reg->cantidad = atoi(numero);
}
//--------------------------------------------------------------------------
 
// Muestra la cabecera de la tabla por pantalla
void MostrarCabecera(void)
{
        printf("\n");
        printf("|---------|-------------------------|--------|\n"
               "|ID       |Nombre                   |Cantidad|\n"
               "|---------|-------------------------|--------|\n");
}
//--------------------------------------------------------------------------
 
// Muestra un producto por pantalla
void MostrarProducto(long n, struct stRegistro *reg)
{
        printf("|[%6ld] |%-25s| %4d   |\n", reg->ID, reg->nombre, reg->cantidad);
}
//--------------------------------------------------------------------------
 
// Lee un número suministrado por el usuario
long LeeNumero()
{
        char numero[6];
        fgets(numero, 6, stdin);
        return atoi(numero);
}
//--------------------------------------------------------------------------
 
// Borra una entrada del archivo
int Borrar(struct stRegistro *reg, long numero)
{
        struct stRegistro temp[SIZEMAX];
        int nRegistros, i, j, encontrado = 0;
 
        nRegistros = CountReg(reg);
        for(i = 0, j = 0; i < nRegistros; i++)
        {
                if(numero != reg[i].ID)
                {
                        temp[j].ID = reg[i].ID;
                        strcpy(temp[j].nombre,reg[i].nombre);
                        temp[j].cantidad = reg[i].cantidad;
                        j++;
                }
                else
                {
                        encontrado = 1;
                }
        }
        if(encontrado == 1)
        {
                if(Confirmar("eliminar la entrada indicada"))
                {
                        memset(reg, 0, sizeof(struct stRegistro) * nRegistros);
                        for(i = 0; i < nRegistros - 1; i++)
                        {
                                reg[i].ID = temp[i].ID;
                                strcpy(reg[i].nombre, temp[i].nombre);
                                reg[i].cantidad = temp[i].cantidad;
                        }
                }
                else
                {
                        encontrado = -1;
                }
        }
        return encontrado;
}
//--------------------------------------------------------------------------
 
int Confirmar(char *operacion)
{
        char valor;
        int salida = 0;
 
        printf("Esta apunto de %s. Pulse 'S' y pulse intro para confirmar: ", operacion);
        valor = getchar();
        if(valor == 's' || valor == 'S')
        {
                salida = 1;
        }
        return salida;
}
//--------------------------------------------------------------------------
 
int CountReg(struct stRegistro *reg)
{
        int i;
 
        for(i = 0; i < SIZEMAX; i++)
                if(strcmp(reg[i].nombre, "")==0)
                        break;
        return i;
}
//--------------------------------------------------------------------------

lo cierto es que tienes la licencia para un pc pero nadie aquí ha dicho que requiera internet así que si se puede usar sin internet y fuera de una red domestica donde haya algún pc que lo tenga instalado pues supongo que funcionará sin problemas. De todos modos yo buscaría las apis típicas para eso y luego probaría a ejecutarlo con internet a ver que puedo ver y luego fuera de internet y ver que cambia en su ejecución y seguro verías algo interesante.

con array de estructuras es mas sencillo y claro que puedes anidar structs dentro de structs sin problemas. Ojalá te sirva de ayuda.