Mensajes

El problema se debe al uso del operador ">>", cuando su operando es de tipo "char *" este lee (y almacena en la dirección indicada) una palabra. La solución es utilizar la función std::istream::getline, una opción mejor es utilizar la clase string y la función std::getline.

Un saludo

Si tu código esta dentro de los estandares ANSI C entonces deberías poder crear un ejecutable portable para todos los SO's

No, lo que es portable (si se sigue el estandar de C) es el codigo fuente.

Un saludo

[eferion]

Hay algún problema con la forma que yo he propuesto?

Al convertir la dirección de tipo "unsigned char *" a "unsigned short *" surgen dos problemas: 1) el ya comentado por eferion y 2) el puntero resultante debe cumplir con los requisitos de alineación para el tipo "unsigned short *".

Otra opción es utilizar una unión cuyos campos sean arrays: uno de caracteres y otros mas de tipo short, int, etc. pero en este caso hay que revisar la documentación del compilador para saber si se soportan lecturas/escrituras intercaladas (escribir utilizando el array de caracteres y luego leer utilizando el array de short's). Asi se elimina el problema de alineación pero queda el otro (orden de los bytes).

La única solución portable que recuerdo es utilizando los operadores de desplazamiento y OR a nivel de bits.

Un saludo

[eferion]

Sólo tengo un problema, y es que mi matriz declarada tiene que ser declarada como char.

Entonces declara el array con el tipo unsigned char.

De ahí el problema:
0xAA, 0xBB declarados ambos como char deben pasar a ser 0xAABB.

Utilizando los operadores de desplazamiento y OR a nivel de bits:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <limits.h>

int main(void)
{
   unsigned char byte[] = {0x00, 0xFF, 0x01, 0x03, 0x01, 0xAA, 0xBB, 0x00};
   unsigned short sh = byte[5] << CHAR_BIT | byte[6];
   
   printf("0x%X + 0x%X ==> 0x%X\n", byte[5], byte[6], sh);
   /* Imprime: 0xAA + 0xBB ==> 0xAABB */
   
   return EXIT_SUCCESS;
}

Otras formas, como ya te comento eferion, tienen sus problemas.

Un saludo

Supongo se trata de C, ¿Correcto?

Un problema importante es la declaración del array:

Código (c) [Seleccionar] Expandir

char codigo[] = {0x00, 0xFF, 0x01, 0x03, 0x01, 0xFF, 0xFF, 0x00};
Ya que el tipo de los elementos es char y este usualmente tiene un rango valido de -128 a 127, si tratas de almacenar un valor mayor como 255 se genera comportamiento no definido.

Para concatenar los dos bytes la forma mas fácil es desplazando el byte mas significativo a la izquierda un numero de bits indicado por la macro CHAR_BIT (usualmente ocho) y al resultado se le realiza una operación OR con el byte menos significativo. Por ejemplo:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <limits.h> /* CHAR_BIT */

int main(void)
{
   int num[] = {0x00, 0xFF, 0x01, 0x03, 0x01, 0x4F, 0x33, 0x00};
   
   printf("0x%4X\n", num[5] << CHAR_BIT | num[6]);
   
   return EXIT_SUCCESS;
}

Un saludo

No es necesario pasar la longitud de una cadena "a la C" ya que el carácter '\0' marca el final de esta y puede utilizarse como condición de salida en la función recursiva:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
using namespace std;

void imprimir(char *p);

int main()
{
   char cad[] = "anitalavalatina";
   
   cout << cad << endl;
   imprimir(cad);
   cout << endl;
   
   return 0;
}

void imprimir(char *p)
{
   if (*p != '\0'){
      imprimir(p + 1);
      cout << *p;
   }
}

Un saludo

Un comentario. Se recomienda evitar la sustitución de la división por el desplazamiento de bits como en este caso:

Código (c) [Seleccionar] Expandir

medio = (inicio + fin) >> 1;
Porque en el desplazamiento a la derecha de un entero con signo si el bit de relleno es cero o uno depende de la implementación. En el caso de enteros sin signo donde el bit de relleno esta garantizado (es cero) es mejor dejar ese tipo de mejoras al compilador.

Un saludo

La librería ctype.h te ayuda bastante en este caso

El valor de retorno de getchar es de tipo int para asi poder devolver cualquier caracter o EOF en caso de un error o fin de archivo y como los casos son exclusivos se pueden utilizar directamente las funciones isupper, islower e isdigit:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <ctype.h>

int main(void)
{
   int ch;

   printf("Ingrese un caracter: ");
   fflush(stdout);
   ch = getchar();

   if (isupper(ch))
      puts("Es una letra mayuscula");
   else if (islower(ch))
      puts("Es una letra minuscula");
   else if (isdigit(ch))
      puts("Es un numero");
   else
      puts("Es un algun otro caracter");

   return 0;
}

Un saludo

¿Sabrías decirme el pequeño bug de la imagen? Hace que cuando le de a "s" o "n" para responder a la pregunta me obligue a escribir algo para poder seguir.

El problema es la cadena de formato al pedir confirmación:

Código (c) [Seleccionar] Expandir

printf("\nQuieres introducir otro producto (s/n)? ");
scanf(" %c ", &otroProducto);
Utilizas " %c " cuando debería ser " %c".

Un saludo

[estructura ligada]

Se puede inicializar toda la estructura a cero? y no las variables individuales?

Es posible, solo tienes que indicar el valor del primer campo y los restantes se inicializan a 0, 0.0 o NULL dependiendo de su tipo. Por ejemplo:

Código (c) [Seleccionar] Expandir

struct foo {
   int i;
   double d;
   char *p;
};

struct foo a = {0}; /* i == 0, d == 0.0, p == NULL */

No estoy seguro de abrir un nuevo tema, para crear una estructura ligada, en este caso es posible autoreferenciar? Estamos viendo en clase estructuras que contienen un apuntador que apunta a otra estructura de la misma forma que contiene tambien un apuntador que da a otra estructura etc...

Como es que se utiliza esto? o como funciona?

Los casos mas conocidos son las listas vinculadas y arboles. Tutoriales sobre ellos los puedes descargar de la pagina (en ingles) Stanford CS Education Library.

Un saludo