Programación General > C/C++

 Declaraciones C++

(1/2) > >>

Carlota:
Hola! Soy nueva en el foro... dejo este ejercicio bastante corto que consiste en realizar declaraciones, pero me he quedadado atrapada >.<

a) Un tipo enumerado que se llame logico y tenga como posibles valores las constantes V y F
int logico(int V, int F);

b) Una variable f como un puntero a funcion, (funcion que recibe un puntero a un entero y una matriz de caracteres de 2 filas y 3 columnas y no devuelva nada).
void *(pf)(*int, m[2][3]);

c) Una variable v como un vector de 10 punteros a entero.
int *v[10];

d) Una variable p-v como un puntero a un vector de 8 punteros a float.
float *( *(p-v)[8] );

e) Una variable c como una cadena de caracteres que pueda contener una cadena de longitud 10.
char cad[10], c[cad];

No se si esta regular o muy mal, pero me gustaria saber resolverlo para aclarar mis dudas.

Gracias de antemano!

czealt:
Hola, bueno las respuestas correctas

EI: NO SE HACEN TAREAS

Carlota:
Como va a ser una tarea si no estan las facultades abiertas en verano??... es un ejercicio que no se resolver :S

EI: no en todo el mundo es verano  :rolleyes:

Tan solo queria que me dijerais si las soluciones se encaminan a lo que he escrito y que me dierais alguna aclaracion de como habeis llegado a las soluciones para saber hacer mas ejercicios como este...

czealt:

--- Citar ---La regla del derecha-izquierda
Esta regla les puede servir para interpretar declaraciones de punteros complejas. La regla dice lo siguiente:
Comenzá leyendo la declaración desde nombre que está en el parentesis más interno, despues leé a la derecha y despues a la izquierda. Luego, cuando termines de leer el parentesis,
saltar hacia afuera y comenzar leyendo de derecha a izquierda nuevamente. Continuar hasta que toda la declaración haya sido leida.

Vamos con un ejemplo:

int * (* (*fp1) (int) ) [10];
Esto puede ser interpretado de la siguiente manera:

1.Comienzo por el nombre de la variable --------------------------- fp1
2.Nada a la derecha, voy a la izquierda y leo * ------------------- es un puntero
3.Salto fuera del parentesis y encuentro (int) --------------------- a una función que recibe un entero
4.Voy a la izquierda y leo * ---------------------------------------------- y retorna un puntero
5.Salto fuera del parentesis, voy a la derecha y leo [10] ----- a un array de 10
6.Voy a la izquierda y leo * --------------------------------------------- punteros
7.Voy a la izquierda y leo int ------------------------------------------- a enteros.
Aca hay otro ejemplo más complicado:

int *( *( *arr[5])())();
1.Comienzo por el nombre de la variable --------------------- arr
2.Voy a la derecha y encuentro un array --------------------- es un array de 5
3.Voy a la izquierda y encuentro * ------------------------------ punteros
4.Salta fuera del parentesis, a la derecha leo () ----------- a funciones
5.A la izquierda leo * ------------------------------------------------ que retornan punteros
6.Fuera del parentesis, a la derecha encuentro () --------- a funciones
7.A la izquierda encuentro * --------------------------------------- que retornan punteros
8.A la izquierda leo int --------------------------------------------- a int's.

--- Fin de la cita ---

Fuente: Wikipedia

Carlota:
Le he estado dando muchas vueltas al mensaje que has dejado aqui sobre wikipedia y la verdad esque a lo unico que he podido llegar es a esto:

a) int logico (int v, int f);

b) void *(fp)(int *, m[2][3]);

c) int * v[10]

d) float * (*(p-v) v) [8]

e) char c[10]

Me diras que no lo he cambiado mucho, pero esque con lo que me has dejado no soy capaz de hacer mas nada... no se donde encontrar informacion sobre declaraciones asi con tipos enumerados, vectores o cadenas :(
Al menos espero que haya alguna declaracion bien T_T

Navegación

[0] Índice de Mensajes

[#] Página Siguiente