Buenas, me surgió la duda si es posible realizar una función que devuelva un puntero con la dirección de memoria de una variable static definida dentro de la función. por ejemplo pasarle la dirección de un arreglo definido como static dentro de una función.
la idea de esa función, es que quien la usa no se deba preocupar por el largo del arreglo debido a que este se crearía en la misma función (dentro de un if{..} por ejemplo).

Buenas resulta que compile el siguiente codigo:

Printf("%d",~((unsigned char)~0));
 

Al compilarlo da -256
Segun la logica que sigo yo y sabiendo que un char tiene 8 bits no entiendo como llega a ese resultado.

Primero al cero le realiza su complemento a1 por lo que queda todos unos,sabiendo que el char tiene ocho bits queda 11111111 que seria el numero 255. Y si luego a todos esos unos se le realiza su complemento a1 quedan todos ceros.

Buenas estoy intentando no usar corchetes en el código pero no funciona como quiero, creo que es porque no entiendo bien cuando están explictos (cuando no son necesarios)

while(expresion)
    if(expresion)
        if (expresion)
            while(expresion)
                ;  //solo hace lo de adentro del while
        else
            while(expresion)
                ;  //solo hace lo de adentro del while
    else{
        if(expresion)
            expresión; //solo una linea
        else if(expresion)
            expresion; //solo una linea
        else if(expresion)
            expresion; //solo una linea
        else if(expresion)
            expresion; //solo una linea
        if (expresion) //nuevo if
            expresion; //solo una
    }
if (expresion) //este if no estaria adentro del primer while
    expresion; //solo una linea
else
    expresion; //solo una linea
 

segun lo que yo entiendo por los paréntesis explícitos, todas las sangrías que he dejado son correctas, pero el código no hace lo que pido.

gracias!!!

3/8=0,375 por lo tanto 4%8 debe ser 3
4/8=0,5 por lo tanto 4%8 debe ser 5

Buenas escribo el siguiente codigo en c:

#include <stdio.h>
int main(void)
	{
		int c,i;
		for(i=0;i<=8;i++)
			printf("el modulo entre %d y 8 es: %d\n",i,i%8);
		return 0;
	}	
 

y lo que me sale es esto:

el modulo entre 0 y 8 es: 0
el modulo entre 1 y 8 es: 1
el modulo entre 2 y 8 es: 2
el modulo entre 3 y 8 es: 3
el modulo entre 4 y 8 es: 4
el modulo entre 5 y 8 es: 5
el modulo entre 6 y 8 es: 6
el modulo entre 7 y 8 es: 7
el modulo entre 8 y 8 es: 0

pero creo que tendría que ser esto:
el modulo entre 0 y 8 es: 0
el modulo entre 1 y 8 es: 1
el modulo entre 2 y 8 es: 2
el modulo entre 3 y 8 es: 3
el modulo entre 4 y 8 es: 5
el modulo entre 5 y 8 es: 6
el modulo entre 6 y 8 es: 7
el modulo entre 7 y 8 es: 8
el modulo entre 8 y 8 es: 0

que seria el primer numero después de la coma

Buenas estaba viendo una posible implementacion de la función fgets, que esta en el libro "el lenguaje de programacion C".

char *fgets(char *s, int n, FILE *iop)
{
register int c;
register char *cs;
 
cs=s;
while (--n>0&&(c=getc(iop))!=EOF)
    if ((*cs++=c)=='\n)
        break;
*cs='\0';
return (c==EOF&&cs==s)?NULL : s;
}
 

mi duda es, para que fgets funcione "s" debe ser un arreglo o tener asignado una memoria con malloc o calloc y n no puede ser mayor a la cantidad de celdas reservadas.

creo que los ultimos tres tabla esta mal, se refiere al nombre de la estructura que es table.

acá el link de donde saque el código:

http://www.it.uc3m.es/abel/as/MMC/M2/HashTable_es.html

typedef struct{
 char *name;
 int nia; 
}datos;
struct elemento_t{
 datos valor;
 struct elemento_t *next;
};
typedef struct elemento_t elemento_type;
typedef struct{
 int tamanho;
 int num_elementos;
 double densidad_deseada;
elemento_type **tabla;
}tabla_type;

el primer typedef define un tipo de datos llamado "datos" que es una estructura que tiene un puntero a char y un entero.
luego define otra estructura llamada elemento_t que adentro contiene una estructura tipo "datos" creada anteriormente y que tiene el nombre valor, y un puntero a la misma estructura.
luego lo que hace es definir a la estructura ultima como un tipo de dato llamado elemento_type.
por ultimo define una estructura como table_type que contiene dos enteros, un double y un apuntador que apunta a apuntadores que apuntan al tipo de dato elemento_type.

AHORA BIEN, MI DUDA VIENE EN EL SIGUIENTE PEDAZO DE CÓDIGO:

tabla_type table;
int i;
table.tamanho=20;
tabla.num_elementos=0;
tabla.densidad_deseada=0.25;
tabla.tabla = (elemento_type **) malloc (sizeof(elemento_type *)*table.tamanho);
for (i=0;i<table.tamanho;i++)
{
     tabla.tabla[i]=NULL;
}
 

¿a que se refiere la expresión "tabla.tabla"?

se que tabla es un puntero que apunta a un puntero que apunta a una estructura de tipo elemento_type

lo que me confunde es el signo de puntuación, según entiendo con el signo de puntuación se entra a los miembros de una estructura.

haa, el cast seria porque las funciones tienen  como argumentos punteros a char y el puntero a la función espera punteros a void ¿no?. es decir ¿los argumentos de las funciones que son punteros a char se convierten a punteros a void?¿cuando se vuelven a convertir en punteros char?