Como demostrar que una estructura vive en la pila

On Sat, 20 May 2006 13:13:01 +0200, Viviana
wrote:

Hola a todos y gracias de antemano por su ayuda. Soy nueva en esto y
tengo
que hacer un proyecto donde pueda demostrar que una estructura se aloja
en la
pila con un programa en C#. Ojalá alguién pueda orientarme sobre que
dirección debo de tomar para desarrollarlo. Gracias nuevamente :-)

En C# no sé, pero en C++/CLI, una clase o estructura definida como "value
class" o "value struct" (recuerda, en .NET las estructuras y las clases
son lo mismo salvo el modificador de acceso por defecto) queda almacenada
en la pila... hasta que se accede a algún método de ella, momento en el
que se copia y se mete en el montículo (ignoro el motivo por el cual se
fuerza esto).

En C#, hasta donde yo sé, sólo los tipos nativos básicos son tipos-valor,
y no existe el concepto de tipo-agregado-en-la-pila, porque todo son
referencias.

Independientemente de eso, y salvo opinión en contra más autorizada que la
mía, con el soporte del C# no se puede saber de ninguna forma. Otra cosa
es que mediante reflexión o el ildasm se pueda.

Visita mi blog: http://rfog.blogsome.com
Libros, ciencia ficción y programación
Uno es para siempre responsable de lo que domestica.
Principito.

Hola gracias por tu ayuda. En C# las estructuras son de tipo valor, al igual
que los tipos nativos (char, bool, int, short, long, decimal, float... etc),
según John Sharp y Jon Jagger en su libro Microsoft Visual C# .Net Aprenda
Ya, edición en español McGraw-Hill del 2002 , en las páginas 153-156 lo
vienen a afirmar. Al igual que Charles Petzold en su libro Programaicón en
Microsoft Windows con C# en el capitulo Estructuras Basicas también dice que
las estructuras son de tipo valor y que viven en la pila. De hecho C# define
a las estructuras como tipo valor definos por el usuario.
El problema es que he encontrado varios autores que lo vienen a afirmar pero
lo quiero comprobar mediante código, para que no me digan que me lo contaron,
jejejeje. Gracias te agradezco de todos modos.

On Sat, 20 May 2006 16:37:02 +0200, Viviana
wrote:

Hola gracias por tu ayuda. En C# las estructuras son de tipo valor, al
igual
que los tipos nativos (char, bool, int, short, long, decimal, float...
etc),
según John Sharp y Jon Jagger en su libro Microsoft Visual C# .Net
Aprenda
Ya, edición en español McGraw-Hill del 2002 , en las páginas 153-156 lo
vienen a afirmar. Al igual que Charles Petzold en su libro Programaicón
en
Microsoft Windows con C# en el capitulo Estructuras Basicas también dice
que
las estructuras son de tipo valor y que viven en la pila. De hecho C#
define
a las estructuras como tipo valor definos por el usuario.
El problema es que he encontrado varios autores que lo vienen a afirmar
pero
lo quiero comprobar mediante código, para que no me digan que me lo
contaron,
jejejeje. Gracias te agradezco de todos modos.

Prueba con punteros y direcciones de memoria...

Visita mi blog: http://rfog.blogsome.com
Libros, ciencia ficción y programación
La enorme multiplicación de libros, de todas las ramas del conocimiento,
es uno de los mayores males de nuestra época.

lo quiero comprobar mediante código, para que no me digan que me lo
contaron,

Bueno, a veces hay que creer lo que nos cuentan, ¿no?
Todo sistema de conocimientos parte de un conjunto de axiomas o "leyes" que
se aceptan como verdaderos sin demostración.

Es fácil escribir un programa que muestre que las estructuras son tipos
valor, o sea que almacenan su valor DIRECTAMENTE. Por ejemplo,

public struct Punto
{
public int X, Y;
}

public static void Main(string[] args)
{
Punto a;
a.X = 50;
a.Y = 50;

Punto b = a;
b.X = 75;

Console.WriteLine("a = ({0}, {1})", a.X, a.Y);
}

El programa imprimirá "a=(50, 50)", mostrando que al haber asignado "b =
a;", b ha obtenido su propia "copia", y que al modificar b a no se ha visto
afectada.
Si en ese mismo programa pones "class" en lugar de "struct", verás que el
resultado es diferente. Obtendrías "a=(75, 50)" porque las clases son tipos
referencia y después de "b = a;" ambos apuntan al mismo objeto, co lo que la
modificación hecha a b afectará también a a.

Si en lo que estás pensando es en obtener la dirección de una variable para
ver si está en la pila, tendrás que recurrir al código inseguro (unsafe):

http://www.csharpfriends.com/Spec/i...cID%.2.htm

Mediante el código inseguro podrás obtener la dirección de una variable
utilizando el operador & (address-of). Pero cuando obtengas esa dirección,
¿cómo demuestras que pertenece a la pila?

Slds - Octavio

On Sun, 21 May 2006 11:22:46 +0200, Octavio Hernandez
wrote:

lo quiero comprobar mediante código, para que no me digan que me lo
contaron,

Bueno, a veces hay que creer lo que nos cuentan, ¿no?
Todo sistema de conocimientos parte de un conjunto de axiomas o "leyes"
que
se aceptan como verdaderos sin demostración.

Es fácil escribir un programa que muestre que las estructuras son tipos
valor, o sea que almacenan su valor DIRECTAMENTE. Por ejemplo,

public struct Punto
{
public int X, Y;
}

public static void Main(string[] args)
{
Punto a;
a.X = 50;
a.Y = 50;

Punto b = a;
b.X = 75;

Console.WriteLine("a = ({0}, {1})", a.X, a.Y);
}

El programa imprimirá "a=(50, 50)", mostrando que al haber asignado "b > a;", b ha obtenido su propia "copia", y que al modificar b a no se ha
visto
afectada.
Si en ese mismo programa pones "class" en lugar de "struct", verás que el
resultado es diferente. Obtendrías "a=(75, 50)" porque las clases son
tipos
referencia y después de "b = a;" ambos apuntan al mismo objeto, co lo
que la
modificación hecha a b afectará también a a.

De parvularios y yo sin caer. En fin, que para algo están los maestros. :-)

Si en lo que estás pensando es en obtener la dirección de una variable
para
ver si está en la pila, tendrás que recurrir al código inseguro (unsafe):

http://www.csharpfriends.com/Spec/i...cID%.2.htm

Mediante el código inseguro podrás obtener la dirección de una variable
utilizando el operador & (address-of). Pero cuando obtengas esa
dirección,
¿cómo demuestras que pertenece a la pila?

Slds - Octavio

Obtendría la dirección base de la variable que referencia a la estructura
y luego la de un subelemento, si ambas son contiguas o cercanas en un
offset razonable, sabría que todo está en la pila, si hay un salto grande
es que la variable está en la pila y es una referencia a algo que está en
el montículo... Otra opción sería obtener el mapa que genera el linkado y
mirar ahí las direcciones, aunque tu forma es mucho más sencilla, claro.

struct pepe{int a, int b, int c};

void main(void)
{
pepe s;

void *p1=(void *)&s;
void *p2=(void *)&s.b;
int diff=p2-p1;
if(abs(diff)>2*sizeof(int))
; //es una referencia.
}

En C++ o C++/CLI la cosa es mucho más fácil, puesto que tenemos el * por
un lado y el ^ por el otro. ;-)

PS: Fíjate, Octavio, que pese a ser lenguajes CLI los dos, el C++ es
completamente diferente al C# en muchísimas cosas, tanto que casi son
incompatibles, aunque tengan traducción casi directa. Conforme voy
haciendo cosas con el C++/CLI más me enamoro de él, pese a sus ochocientos
mil bugs (aparte de los ochocientos mil del .NET). Si estás interesado en
una aventura caza-bugs, leete esto:
http://rfog.blogsome.com/2006/05/19...-datagrid/

PSS: Por cierto, el manual aquel del C++/CLI está casi acabado...
Visita mi blog: http://rfog.blogsome.com
Libros, ciencia ficción y programación
La enorme multiplicación de libros, de todas las ramas del conocimiento,
es uno de los mayores males de nuestra época.