Concatenar vectores en tiempo de diseño
 

Hola a todos!

Tengo una dudilla sobre vectores, os cuento:

Tengo un vector definido como constante como sigue:

y otro vector que me gustaría que fuese (varios elementos,los elementos de vect1, mas elementos), y me gustaría hacerlo en tiempo de diseño (es decir, escrito en código). Algo del estilo:

Evidentemente, el compilador no traga que ponga vect1 como constante (me da error: Constant expression expected), aunque sí que me permite que la longitud se la dé con la función length.

¿Hay alguna forma de conseguir hacer esto?
Gracias de antemano,
Un saludo,
LoPiTaL

Hola otra vez. Haciendo pruebas he intentado lo siguiente, y tampoco me deja:

Lo he intentado hacer como records y tampoco me deja hacerlo. Os pongo el código:

Esta vez el error que da es: '(' expected but identifier 'vect1' found.

¿Ideas?

Un saludo,
LoPiTaL

Hola,
¿no te seria mas practico no utilizar vectores constantes?

Me daría igual que estuviesen declarados como const o como var, nunca voy a escribirlos, así que no tengo problema en eso.
Lo que sí que me gustaría es poder inicializarlo por código, sin tener que ejecutar nada, con el fin de que simplemente cambiando la definición de vect1, automáticamente me cambien el resto de definiciones en las que vect1 aparece (ya que no sólo aparecerá en vect2, sino que aparecerá en bastantes otras definiciones).

El último recurso es hacerlo en un bloque "initialization", pero no me gustaría tener que hacerlo así.

Implementándolo como var tampoco me deja compilar.

Gracias por la respuesta,
Un saludo,
LoPiTaL

¿Podrías subir tu archivo .pas real o una versión simplificada del mismo? Tal vez observando más información de contexto (como el propósito de esos vectores) podríamos idear otras soluciones. :)

El problema está en declarar vectores como constantes, asignándole un vector a otro.
Hacelo con variables, creo que funciona. En unos 10 minutos me fijo, ahora no puedo.
Veo y te digo, nos vemos!!!

Recién vuelvo, tuve problemas con una note que no detectaba la webcam.
Bueno, mirá.
Toqueteando D2010 llegué a la única conclusión de que no se puede hacer esa asignación en diseño (o sea, "codeando") porque no hay ningún dato almacenado en memoria como para que el compilador puede asignar.
Me refiero a que, cuando el compilador lee algo como "f2: vect1;" o "const vect2: array [0..2+length(vect1)-1] of integer=(-2,-1,vect1,3);" dice "bueno, yo no almacené ningún dato, no puedo hacer eso, te tiro un error". Espero que con esa explicación ligeramente tonta se pueda entender mi concepto.
A mi limitado entender, lo único que podés hacer es asignar los datos en ejecución.

Saludos y espero haberte ayudado a entender!

Yo quiero saber cuál fue la confusión :D:D:D:D:D:D

Es que pensé que tú eras el autor original del hilo. :D

-----------------------------------------------------

CONFUSIÓN:

Cita:

Empezado por BrunoBsso, creyendo Al que se trataba de LoPiTaL Saludos y espero haberte ayudado a entender!

No, si entendido está desde hace varias horas. Como todos los lenguajes, Delphi tiene sus limitantes. Mi inquietud está en ver qué hay detrás de la tuya. Claro, si tú quieres. :)

END CONFUSIÓN

Ahhhhh me habías escrito eso? Jajajajjajajaja
END CONFUSIÓN jajajajjajaja

Hola a todos! Gracias por las respuestas.

Pues no puedo daros el pas real, ya que son muchos todos con defines de este estilo, y no dan mucha información.
Lo que sí puedo daros es para qué quiero estas definiciones, os comento:

Estoy haciendo una aplicación cliente-servidor, en la que el servidor es el PC que corre la aplicación, y los clientes son dispositivos con un microcontrolador. El problema es que Delphi (no sé si Delphi o los PCs) trabajan en little-endian, y el uC que utilizo trabaja en big endian. Uso estructuras de datos, para transmitir de PC a uC o viceversa, que mezclan enteros, singles, words y booleans (ya me encargo yo de alinear a 4 bytes para que no hayan huecos de memoria en C -sí, otro problema es que los uC los programo con C), y para realizar la conversión he hecho un procedure que lee un puntero a estructura y un vector con los tamaños de los campos de la estructura, y entonces puede hacer el cambio de endian a estructuras más completas sin necesidad de ir campo a campo, como he visto en muchos ejemplos que hay por la web.

Hasta aquí bien. El problema me ha aparecido cuando he pasado a realizar estructuras más complejas, en el que uno de los campos es otra estructura, por lo que necesitaría un vector de vectores (en el caso más básico) o un vector de vector de vector de vectores (si la estructura contenida en un campo contiene a su vez otra estructura, etc, etc...). Y no sólo es un vector de vectores, sino que en el vector "padre" hay enteros y uno de los items del vector (el relacionado con la estructura hija) es otro vector con la info de la otra estructura.
Utilizo el vector como un indicador del tamaño de cada uno de los campos de tal forma que la función sea capaz de reconocer qué tamaño tiene cada campo y realizar el cambio de endian de manera correcta.
Entonces, si cambio un campo en una estructura que está dentro de otra, me gustaría que cambiando exclusivamente su vector de definición, se actualizasen los vectores de definición de las estructuras "padre".

¿Por qué no me gustaría hacerlo en código? Porque pierdo un poco la noción de qué estoy haciendo, además de quedar separadas la declaración de la estructura y la declaración de su vector de datos, siendo más fácil que se me olvide cambiar la definición del vector cuando cambio la estructura.

Espero haber sido bastante claro. Sé que es algo enrevesada la idea, pero es lo único que se me ha ocurrido, desde el momento en que me dí cuenta que no existía información RTTI para estructuras.

Dicho todo esto, ¿se os ocurre alguna forma más sencilla de trabajar con cambios de endian para estructuras complejas? A mí no se me ocurre nada sencillo, y he estado dándole muchas vueltas, desde todo lo dicho anteriormente, hasta el uso de clases y tal, pero no se me ha ocurrido cómo usar clases para realizar la tarea de la forma más automatizada posible.

NOTA: donde digo estructura me estoy refiriendo a record :)

Gracias nuevamente por las respuestas,
Un saludo,
LoPiTaL

Hola otra vez,
Revisando los posts me he dado cuenta de que es curioso que sí que me permite hacer length(vect1) :eek:, así que por lo menos algo sabrá sobre vect1, ¿no?

Un saludo,
LoPiTaL

Porque la función Length(Vect1) es en tiempo de ejecución, no le da ningún dato al programa al compilar :rolleyes:
O sea, Length la usa el programa en tiempo de ejecución, no mientras estás codeandolo, y es ahí en la ejecución cuando devuelve algún dato.
Un saludo

Me parece que no puede ser como lo dices. Una construcción del tipo

Código Delphi [-]
const
  V: array[A..B] of Integer = (...)

requiere que A y B sean constantes, es decir, que sean conocidos al momento de la compilación, ya que el tipo de datos corresponde a un arreglo de tamaño fijo.

En una construcción como:

Código Delphi [-]
const
  U: array[0..2] of Integer = (...);
  V: array[0..Length(U) - 1] = (...);

seguramente el compilador calcula el valor de Length, cosa que puede hacer porque el mismo vector U es constante y ya está determinada su longitud desde la compilación. Esto debe ser "magia" del compilador, pues no sucedería lo mismo con otra función.

Si cambiamos la definición a algo como:

Código Delphi [-]
var
  U: array of Integer;

const
  V: array[0..Length(U) - 1] = (...);

ya no compila, pues, siendo U un vector dinámico, el compilador no tiene manera de saber cuál es su longitud y requiere una constante para el índice superior de V.

// Saludos

Según recuerdo la teoría de compiladores, no obtiene un resultado de Length en compilación, lo obtiene solo en ejecución.
Y al hacer un vector estático y querer asignarle la longitud a otro vector dinámico no puede hacerlo porque el dinámico no tiene ningún dato todavía.
Me parece a mí, no se.