C/Visual C - Problema estructuras en archivos binarios

Gente estoy teniendo un problema con una estructura. Cuando intento grabarla en un archivo binario va modificando su tamaño a medida que se le agregan registros. Aviso que uso la consola y no objetos, o sea Archivos .CPP

typedef struct
{
char talle[2];
char descripcion[20];
float valor;
int codart;
int stockact;
int codrubro;
int activo;
int codmarca;
}articulo;

Esta es la estructura que tengo creada para el articulo.

arcarticulos=fopen("articulos.dat","a");
fwrite(&auxart,sizeof(articulo),1,arcarticulos);

De esta forma hago que se vaya agregando al archivo binario, al final del mismo.

Ahora por alguna razon, cada vez que se envia informacion algo pasa.
Al comienzo cuando se graba 1 sola estructura son 49bytes, pero cuando se le agrega otra mas pasan a ser 98bytes, para cuando se agrega una 3ra pasan a ser 146.

Lo cual no me permite despues del segundo elemento buscar los siguientes sin hacer un toqueteo asqueroso en el codigo para que encuentre registro por registro casi manualmente.

Alguien sabe que sucede? o si esto es normal y como se puede arreglar?

ACA DEJO TODO EL CODIGO A VER SI PUEDE ALGUIEN AYUDARME YA QUE MAÑANA TENGO QUE ENTREGARLO Y ESTO ME TIENE LOCO DESDE EL DOMINGO.

#include <stdio.h>
#include "Consola.h"
#include <Conio.h>
#include <fstream.h>
#include <dos.h>
#include <windows.h>
#include <string.h>
#include <io.h>

typedef struct
{
char talle[4];
char descripcion[20];
float valor;
int codart;
int stockact;
int codrubro;
int activo;
int codmarca;
}articulo;

void main (void)
{

FILE *arcarticulos;
articulo auxart;
int conf=0,oks=0,maxarc=0,codigo;
bool grabar=true,salir=false;
do
{
clrscr();
printf("\t\t\t\tMENU ARTICULOS\n");
printf("\t\t\t\tALTA ARTICULOS\n");
if ((arcarticulos=fopen("articulos.dat","r"))!=NULL)
{
fseek( arcarticulos,0,SEEK_END);
maxarc=ftell(arcarticulos);
codigo=((maxarc)/(sizeof(articulo)))+1;
fclose(arcarticulos);
}
else
codigo=1;
printf("\nCodigo de Articulo: %d",codigo);
printf("\nDescripcion: ");
fflush(stdin);
gets(auxart.descripcion);
printf("\nTalle: ");
fflush(stdin);
gets(auxart.talle);
printf("\nCodigo Rubro: ");
scanf("%d",&auxart.codrubro);
printf("\nCodigo Marca: ");
scanf("%d",&auxart.codmarca);
printf("\nStock: ");
scanf("%d",&auxart.stockact);
printf("\nPrecio Unitario: ");
scanf("%5.2f",&auxart.valor);
arcarticulos=fopen("articulos.dat","a");
auxart.activo=1;
auxart.codart=codigo;
fwrite(&auxart,sizeof(articulo),1,arcarticulos);
fclose(arcarticulos);
}while(!salir);
fflush(stdin);

}

Yo veo totalmente logico que te vaya incrementando de 49 en 49 BYTES, ya que eso es el espacio que tu estructura articulo necesita, (24 * char + "\0") + float + (5 * int) = 49

Por lo tanto, cuando grabas un articulo, tu fichero es de 49, si grabas dos 2*49 = 98 y asi sucesivamente.

Si solo quieres tener un articulo, usa un fseek para ponerte al principio del fichero, y sobreescribir lo anterior cada vez que grabas algo nuevo.

Si quieres tener mas de un articulo grabado en el fichero, dejalo asi.

Para leer el fichero... usa tambien el sizeof (articulo) para leer una estructura entera por golpe.

Si tienes mas de una estructura en el archivo, mira el tamanyo el archivo, lo divides entre 49 para saber cuantas hay y creas un array de articulos para ese tamanyo.

Vas leyendo estrutura a estructura y guardandolas en el array.

Luego cuando quieras encontrar una estructura particular, recorre el array con un for y consulta tus elementos tranquilamente
if (ArrayArticulos [i].valor == valor_buscado)
//lees o modificas otras cosas dentro del articulo

Espero que te sirva

Sucede Nelek que la estructura tiene un tamaño de 48 no 49 como dices, ya la hice "medi" con el sizeof, las variables enteras ocupan 4 bytes, los char 1byte por cada uno, los flotantes 4 bytes tambien...

Te comento que probe lo siguiente:
sizeof(articulo)
(esta es mi estructura la cual posee 4 INT que son 16bytes, 1 FLOAT que son 4bytes y 3 CHAR uno de 20 y otros dos de 4 que en total suman 28bytes) si los sumas son 48bytes que tiene de tamaño la estructuta..

a continuacion de eso para comprobar lo que digo hice:

sizeof(int)*4
sizeof(float)*1
sizeof(char)*28

la cual me dio el mismo resultado que antes, 48.

Pero ahora sucede que el anterior problema se soluciono.
Ahora el problema que tengo es que cuando va a escribir el registro de estructura numero 9 no lo cierra, lo deja abierto y recien lo cierra en el 10, sinceramente no entiendo que puede pasar y si puede ser problema del compilador de Visual C++, dado que segun mi profesor el comparo el codigo con el de otros dos alumnos, uno del año anterior y otro de otra universidad que tuvieron el mismo ejercicio y el codigo es EXACTAMENTE IGUAL a diferencia que ellos usaron TURBO C++...

Es por esto que yo estoy totalmente desconcertado y si alguien me puede dar una mano se lo agradecere.
El que quiera el programa completo me lo pide y se lo paso para que me ayude.
Me estiraron el plazo de entrega hasta este jueves asi que me seria muy buena cualquier tipo de ayuda.