Deberías aprender a leer los errores que te da el compilador. Tu código tiene un montón de errores:

int nombre[30];
int descripcion[30];

tanto nombre como descripción han sido definidos como un array de enteros... si intentas tratar esto como una lista de strings lo vas a pasar mal.

char nombre[30][50];
char descripcion[30][50];

Ahora, tanto 'nombre' como 'descripcion' permiten almacenar 30 strings diferentes, cada uno con una longitud máxima de 49 caracteres.

---

float ventas(int Nombre[30],int Descripcion[30],int Cantidad[30],float Precio[30],int X,int C);
float impresion(int Name[30],int Descr[30],int Cant[30],float Price[30],int X1,int C1,float Precioto[30],float subto,float tax,float Total,float Altotal);

Vamos a ver, 'nombre', 'descripcion', 'cantidad' y 'precio' van siempre juntos... ¿por qué no los agrupas en una estructura? El código va a quedar mucho más bonito y legible... además, no es prudente usar funciones con muchos parámetros, por lo que interesa reducirlos al máximo:

// Definición de la estructura
typedef struct
{
  char nombre[ 50 ];
  char descripcion[ 50 ];
  int cantidad;
  float precio;
} Articulo;
 
// ...
 
// Declaramos un array de 30 artículos
Articulo articulos[ 30 ];
 
// Acceso a datos del articulo 10
articulos[ 9 ].cantidad = 10;

Con esto, las funciones ahora quedan un poco más legibles:

float ventas( Articulo *articulos, int X, int C );
float impresion( Articulo *articulos, int X1, int C1, float Precioto[30], float subto, float tax, float Total, float Altotal );

Esto aún puede mejorar un poco más, dado que tanto "ventas" como "impresion" van a recorrer toda la lista de artículos, no hace falta pasar 'X':

float ventas( Articulo *articulos, int C );
float impresion( Articulo *articulos, int C1, float Precioto[30], float subto, float tax, float Total, float Altotal );

Y aún se le puede dar una vuelta de rosca más. Dado que el arreglo de artículos debe ir siempre acompañado del total de artículos, parece lógico agrupar estos dos elementos en una nueva estructura:

typedef struct
{
  Articulo lista[ 30 ];
  int totalArticulos;
} Venta;

Con lo que ahora las funciones quedan más limpias todavía:

float ventas( Venta *venta );
float impresion( Venta *venta, float Precioto[30], float subto, float tax, float Total, float Altotal );

Mejor así, no?

---

int x=0,c=0;

¿Qué significa 'x'? ¿y 'c'? no son nombres 'válidos' porque no aportan información acerca de su finalidad. Es complicado seguir un código con variables sin sentido aparente. Hay que facilitar la lectura del código al máximo.

Por ejemplo, 'x' podría llamarse 'idArticulo' y 'c' lo podrías renombrar por 'totalArticulos'.

---

int lectura();
float ventas( ... );
float impresion( ... );

Si las funciones no tienen 'return algo', entonces deberían estar declaradas como 'void funcion':

void lectura();
void ventas( ... );
void impresion( ... );

Además, en C, si una función no está prensada para que reciba argumentos, hay que indicarlo poniendo 'void' entre los paréntesis:

void lectura( void );
void ventas( ... );
void impresion( ... );

---

printf("\nIngrese el nombre del cliente: ");
scanf("%s",&nombre[c]);

En C, los strings son punteros, por lo que sobra ese '&' que tienes ahí

printf("\nIngrese el nombre del cliente: ");
scanf("%s",nombre[c]);

---

do
{
  printf("\nIngrese el nombre del cliente: ");
  scanf("%s",&nombre[c]);
 
  do
  {
    printf("\nIngrese descripcion del producto: ");
    scanf("%s",&descripcion[x]);
    printf("\nIngrese cantidad del producto: ");
    scanf("%d",&cantidad[x]);
    printf("\nIngrese precio individual: ");
    scanf("%f",&precio[x]);
    x++;
    printf("\nIngresar otro producto? S/N ");
    limprod=getch();
  } while(limprod=='s'||limprod=='S');
 
  ventas(nombre,descripcion,cantidad,precio,x,c);
  printf("\nProcesar otro cliente? S/N");
  lim=getch();
  c++;
} while(lim=='s'||lim=='S');

Según este código... cada venta se asocia a un cliente... además este cliente puede adquirir un número indeterminado de artículos... este diseño no te va a permitir nunca guardar un historial de pedidos. Aprovechando la infraestructura que te he comentado, se podría modificar para adaptarla a estos requisitos:

#define MAX_LENGTH 50
#define MAX_ARTICULOS 30
 
typedef struct
{
  char nombre[ MAX_LENGTH ];
  char descripcion[ MAX_LENGTH ];
  int cantidad;
  float precio;
} Articulo;
 
typedef struct
{
  char cliente[ MAX_LENGTH ];
  Articulo articulos[ MAX_ARTICULOS ];
  int numeroArticulos;
} Venta;

He aprovechado también a introducir dos 'defines' porque no me gustan los literales metidos a pelo en el código.

Con este diseño conseguimos que cada cliente tenga su propia lista de artículos, aunque no le saques partido a dicho detalle en esta aplicación.

---

float ventas(int Nombre[30],int Descripcion[30],int Cantidad[30],float Precio[30],int X,int C)
{
    float precioto[30];
    int n=0;
    float subtotal=0,impuesto=0,total=0,altotal=0;
    int cltotal=0;
    for(n=0;n<X;n++)
    {
     precioto[n]=Cantidad[n]*Precio[n];
     subtotal+=precioto[n];
    }
    impuesto=subtotal*0.07;
    total=subtotal+impuesto;
    altotal+=total;
    impresion(Nombre,Descripcion,Cantidad,Precio,X,C,precioto,subtotal,impuesto,total,altotal);
}

¿Es necesario hacer estos cálculos aquí?

Asumiendo que sí, no es un buen sistema porque la llamada a "impresion" tiene demasiados argumentos... imagínate el lío si intercambias por error dos argumentos. Entre otras cosas puede que no seas capaz de ver el error tras muchas horas de sufrimiento.

Apoyándonos nuevamente en el diseño que hemos ido realizando, esto se puede mejorar sustancialmente:

typedef struct
{
  char nombre[ MAX_LENGTH ];
  char descripcion[ MAX_LENGTH ];
  int cantidad;
  float precio;
  float total;
} Articulo;
 
typedef struct
{
  char cliente[ MAX_LENGTH ];
  Articulo articulos[ MAX_ARTICULOS ];
  int numeroArticulos;
  float subtotal;
  float impuestos;
  float total;
} Venta;

Hemos añadido nuevos campos a las estructuras... ahora ya podemos actualizar el código de la función:

void ventas( Venta* venta, float* totalAlmacen )
{
  venta->subtotal = 0;
  venta->impuestos = 0;
 
  int i;
  for( i = 0; i < venta->numeroArticulos; i++ )
  {
    Articulo* articulo = &venta->articulos[ i ];
    articulo->total = articulo->cantidad * articulo->precio;
 
    float impuestos = articulo->total * 0.07;
    venta->subtotal += articulo->total;
    venta->impuestos += impuestos;
  }
 
  venta->total = venta->subtotal + venta->impuestos;
  *totalAlmacen += venta->total;
 
  impresion( venta, totalAlmacen );
}

Fíjate lo sencilla que ha quedado ahora la llamada a "impresion".

Si miras el código, verás que en el bucle uso el puntero "Articulo* articulo = &venta->articulos[ i ]". El puntero lo uso únicamente para reducir la cantidad de código a escribir... si no usase este puntero el código quedaría tal que:

for( i = 0; i < venta->numeroArticulos; i++ )
{
    Articulo* articulo = &venta->articulos[ i ];
    venta->articulos[ i ].total = venta->articulos[ i ].cantidad * venta->articulos[ i ].precio;
 
    float impuestos = venta->articulos[ i ].total * 0.07;
    venta->articulos[ i ].subtotal += venta->articulos[ i ].total;
    venta->articulos[ i ].impuestos += impuestos;
}

Parece obvio que el primer código es más legible.

---

El flujo de tu programa es deficiente.

"lectura" llama a "ventas" y este a su vez a "impresion". Esta cadena de llamadas debería estar controlada desde el "main". Los motivos son varios, pero tampoco es plan de escribir una tesis con este programa. Es importante intentar reducir la dependencia entre funciones.

---

El código final con los cambios aplicados:

#include <stdio.h>
#include <ctype.h>
 
#define MAX_LENGTH 50
#define MAX_ARTICULOS 30
 
typedef struct
{
  char nombre[ MAX_LENGTH ];
  char descripcion[ MAX_LENGTH ];
  int cantidad;
  float precio;
  float total;
} Articulo;
 
typedef struct
{
  char cliente[ MAX_LENGTH ];
  Articulo articulos[ MAX_ARTICULOS ];
  int numeroArticulos;
  float subtotal;
  float impuestos;
  float total;
} Venta;
 
void lectura( Venta* venta );
void ventas( Venta* venta, float* totalAlmacen );
void impresion( Venta* venta, float totalAlmacen );
 
int main()
{
  int x;
  for( x = 0; x < 50; x++ )
    printf("\n");
 
  float totalAlmacen = 0;
  Venta venta;
 
  lectura( &venta );
  ventas( &venta, &totalAlmacen );
  impresion( &venta, totalAlmacen );
  return 0;
}
 
void lectura( Venta* venta )
{
  int i = 0;
 
  printf("\nIngrese el nombre del cliente: ");
  scanf("%s", venta->cliente );
 
  char respuesta;
  do
  {
    printf("\nIngrese descripcion del producto: ");
    scanf("%s", venta->articulos[ i ].descripcion );
 
    printf("\nIngrese cantidad del producto: ");
    scanf("%d", &venta->articulos[ i ].cantidad );
 
    printf("\nIngrese precio individual: ");
    scanf("%f", &venta->articulos[ i ].precio );
 
    i++;
 
    printf("\nIngresar otro producto? S/N ");
    scanf( " %c", &respuesta );
 
  } while( tolower( respuesta ) == 's' );
 
  venta->numeroArticulos = i;
}
 
void ventas( Venta* venta, float* totalAlmacen )
{
  venta->subtotal = 0;
  venta->impuestos = 0;
 
  int i;
  for( i = 0; i < venta->numeroArticulos; i++ )
  {
    Articulo* articulo = &venta->articulos[ i ];
    articulo->total = articulo->cantidad * articulo->precio;
    float impuestos = articulo->total * 0.07;
    venta->subtotal += articulo->total;
    venta->impuestos += impuestos;
  }
 
  venta->total = venta->subtotal + venta->impuestos;
  *totalAlmacen += venta->total;
}
 
void impresion( Venta* venta, float totalAlmacen )
{
  printf("\n");
  printf(" Nombre del cliente: x %s x", venta->cliente );
  printf("\n%-30s | %-10s | %-10s | %-10s",
         "DESCRIPCION",
         "CANTIDAD",
         "PRECIO",
         "TOTAL" );
 
  int i;
  for( i = 0; i < venta->numeroArticulos; i++ )
  {
    Articulo* articulo = &venta->articulos[ i ];
    printf("\n%-30s | %10d | %10.2f | %10.2f",
           articulo->descripcion,
           articulo->cantidad,
           articulo->precio,
           articulo->total );
  }
 
  printf("\n\t\t%20s %6.2f", "SUBTOTAL:", venta->subtotal );
  printf("\n\t\t%20s %6.2f", "ITBMS:", venta->impuestos );
  printf("\n\t\t%20s %6.2f", "TOTAL A PAGAR:", venta->total );
  printf("\n");
  printf("\nTotal Vendido por el Almacen: %.2f", totalAlmacen );
}

Usas C++, por lo que no veo un motivo claro que no te impida usar la clase string.

Además, 'cin', dispone de un método llamado 'getline'. Este método tiene el inconveniente de que requiere cadenas al estilo 'C', sin embargo, la stl dispone también de un método 'getline' y en esta ocasión si permite trabajar con strings.

Además, en C++ no hace falta usar 'typedef' para las estructuras... es redundante y queda feo.

Con estas dos características en mente, la cosa se simplifica bastante:

#include <iostream>
#include <string>
 
struct Persona
{
  std::string nombre;
  unsigned edad;
  char sexo;
};
 
int main( )
{
  std::string cad;
  std::cout<< "introducir en una linea nombre edad sexo: ";
  std::getline( std::cin, cad );
 
  Persona persona;
  int index = cad.find_first_of( ' ', 0 );
  persona.nombre = cad.substr( 0, index );
 
  int last = index + 1;
  index = cad.find_first_of( ' ', last );
  persona.edad = std::stoi( cad.substr( last, index - last ) );
 
  last = index + 1;
  persona.sexo = cad.at( last );
}

PD.: el código asume que estás metiendo los datos correctamente.

El código, si lo decoras con las etiquetas GeSHi, mejor. Además es un requisito en el foro

Si quieres currarte todo el código deberías montar un par de bucles para comparar las cadenas de dos en dos usando, por ejemplo, el algoritmo de burbuja. Para comparar las cadenas puedes usar la función strcmp. Si las cadenas no están en orden, simplemente las intercambias. Para eso puedes usar un string temporal y la función strcpy. Este código no te lo pongo porque no se hacen tareas. Puedes intentar hacerlo tu mismo y volver cuando tengas dudas sobre TU código.

Otra de las muchas formas de hacerlo, esta vez usando la clase string y las bondades de la stl:

std::vector< std::string > orderVecStrings(
          std::vector< std::string > vecStr, int /*largoVecStr*/ )
{
  std::sort( vecStr.begin( ), vecStr.end( ), std::less< std::string >( ) );
  return vecStr;
}

También se pueden ordenar usando el contenedor 'set':

std::vector< std::string > orderVecStrings(
          std::vector< std::string > vecStr, int /*largoVecStr*/ )
{
  std::set< std::string > temp{ vecStr.begin( ), vecStr.end( ) };
  return std::vector< std::string >{ temp.begin( ), temp.end( ) };
}

En cualquiera de los dos casos, ves que ya no se hace necesario el uso del segundo argumento de la función.

Si tenemos 'char** bloque', entonces:

• 'bloque' es un puntero doble a char
• '*bloque' es un puntero a char
• '**bloque' es un char

Se ve entonces claramente que '*bloque' no es lo mismo que '**bloque'

Ejemplo 1:

void funcionInutil( char bloque )
{
  bloque = 'a';
}
 
void funcionUtil( char* bloque )
{
  *bloque = 'a';
}
 
int main( )
{
  char bloque = '0';
 
  funcionInutil( bloque );
  printf( "%c", bloque );
 
  funcionUtil( &bloque );
  printf( "%c", bloque );
}

Ejemplo 2:

void funcionInutil( char *bloque )
{
  bloque = malloc( 20, 1 );
 
  // Imprime la dirección de memoria que acaba de reservar
  printf( "%d\n", bloque );
}
 
void funcionUtil( char **bloque )
{
  *bloque = malloc( 20, 1 );
 
  // Imprime la dirección de memoria que acaba de reservar
  printf( "%d\n", *bloque );
}
 
int main( )
{
  char *bloque = NULL;
 
  funcionInutil( bloque );
 
  // Imprimirá 0, 'bloque' se ha pasado por copia, luego su valor no se puede modificar
  printf( "%d\n", bloque );
 
  funcionUtil( &bloque );
 
  // Ahora si se ha podido modificar 'bloque' porque se ha pasado por referencia.
  printf( "%d\n", bloque );
}

Espero que con estos ejemplos quede un poco más claro el tema de los punteros, las referencias y las desreferencias.

El evitar declarar una variable es un efecto colateral... simplemente es una muestra de que no hay una forma fija y concreta de hacer las cosas en programación.

Bueno, largo o corto la idea es que sea útil, ya me contaréis.

Un saludo a ambos.

doy fe de ello:

if(strcmp(cadena,limpiar) == 0 || strcmp(cadena,limpiarLinux) == 0 || strcmp(cadena,limpiarWind) == 0){
  system("cls");
  // ...
}else if(strcmp(cadena,ayuda) == 0){
  system("cls");
  // ...
}else if(strcmp(cadena,dirwindow) == 0 || strcmp(cadena,lslinux) == 0 || strcmp(cadena,dirdominica)){
  // ...
  system("dir");
}else{
  printf("\t!!! ERROR Comando no Validos.. Entrasr a (help) para ayuda\n");
}

la idea de esas líneas es intercambiar el valor de las dos variables:

te lo pongo con valores binarios:

int a = 20; // 10100
int b = 29; // 11101
 
a ^= b; // a = 01001 b = 11101
b ^= a; // a = 01001 b = 10100
a ^= b; // a = 11101 b = 10100
 
// Despues del codigo:
// a = 29 -> 11101
// b = 20 -> 10100

Esto es equivalente a:

int a = 20;
int b = 29;
 
int temp = a;
a = b;
b = temp;
 
// Despues del codigo:
// a = 29
// b = 20

Esto también se puede hacer con sumas y restas:

int a = 20;
int b = 29;
 
a += b; // a = 49 b = 29
b = a - b; // a = 49 b = 49-29=20
a = a - b; // a = 49-20=29 b = 20
 
// Despues del codigo:
// a = 29
// b = 20

Hay más formas de hacerlo, pero creo que la idea queda clara.

Paso 1: Consigue un buen manual de C.
Paso 2: Lee dicho manual y realiza todos sus ejercicios.
Paso 3: Realiza pequeños programas por tu cuenta para terminar de asentar conocimientos.
Paso 4: Realiza este proyecto, ya no te dará problemas su desarrollo.

A groso modo ese podría ser un buen comienzo para hacer lo que quieres, pero me da que no lo vas a seguir.

En cualquier caso, si tus conocimientos en C son escasos es mejor que te pongas las pilas en C antes de meterte con este programa que, ciertamente, no es el más adecuado para aprender a programar.

El código lo he probado y funciona perfectamente salvo por un detalle... falta un ';' en la línea 14... dudo que compile sin eso. (he usado un compilador C++)