RN1,

Unfortunately, I don't yet know enough about .NET to answer this question
definitively. However, I can tell you that it's entirely possible that the
compiler generates code associated with x that tracks the pointer. Don't
assume there is no pointer just because you don't see it. The compiler does
a great many things behind the scense.

For example, in classic VB, if you declare a String variable a BSTR is
created behind the scenes. This data type involves a pointer. Who would you
say the pointer is returned to in this case?

Hi

No means no as in NO (false), then it should be true types. Sorry for my bad
spelling.

A data type of refernese type is not actually a value. It refers to a value.
A value type is actually a real value. A referense refers to or as in C
points to a value. In all programming languages I stumpled except one you
can have two types of parameters. Call by value or cal by referense. In
Basic you use "ByVal" for call by value and "ByRef" (i guess) for call by
referense. The only exception I know is Smalltalk that uses only referenses.
Every data in Smalltalk is dynamicly created.

As for the C++ code I mentioned gets more complicated when you deal with
classes.

See this example in C++ code. Note I'm not a VB programm only used it for a
small program back in 1998.

class TItem
{
   private int& item;

   //  Default constructor
   public TItem():
       item( *new int; )
   {}

   // Copy contructor
   public TItem( TItem& anInt ):
       item( *new int(anInt); )
   {}

   public ~TItem() { delete *item; }

   public int get() { return item; }
   public void set( int anItem )  { item = anItem; }
}

//  If you didnä't define the copy and default constructors above
//  This function would fail to compile since it is call by value.
void aFunction( TItem item )
{
// CODE
}

Now having said this about C++ it is essential to know if all parameters in
C# is treated as referenses or if you can use both cal by value and call by
referense.

On Feb 10, 4:38 am, "Jonathan Wood" <jw...@softcircuits.com> wrote:

ANSI Pascal string at least the old ANSI pascal string type looks as follow

[YXXXXXXXX....XXX]

Where Y is a Byte giving 0..255 as the length of the string. X is caracters
all ANSI strings are arrays. In Delphi which is base on pascal I recall old
ansi Pascal string was replaced with ShortString or some thing. If you use
Delphi 2.0 or later the arrays for the caracters are as you say stored in
array that the string points to. It's been a while sine I dugg into the ANSI
defenitions for C++ but the only string type I know of in C++ is made of
template classes. Old C has no string type at all, hence the need for
pointers to awways.

I do know what call by referense and call by value is. What I don't know
(yet) is if C# can use both as C++ can. To me C# looks reminds me of both VB
and C++.

Read the page, good that the authour describes "Deep and Shallow Clones"
what I mentioned as Deep Copy or Shallow Copy. Some thing you learn when
studing basics in Object Oriented Program (OOP) as I did. Thet's when I
learned Smalltalk. If you use Delphi for example evey object of type class
that you pass in the parameter list is in fact a referense. The Deep Copy
versus Shallow copy of objects are not an easy thing to deal with. This can
mess up a lot for you if you don't know. Imagine if you uses a String class
that used Shallow Copy only. Setting

S2 = S1;
S1 = S3;

Would give the result that S1 and S2 had the same value as S3. As I
understand from the page you refered me to C# is doing a Deep Copy. If you
know OOP this should not be that hard to understand. If you don't know about
OOP then you need to study OOP and the problem with Deep Copy versus Shallow
Copy.

Good wuestion about the DIM variable.

In C/C++, Delphi the referense that points to DIM is owned by the functions.
Once you exit the function the reference varialbe dissapears.

The even better question is who owns the pbject you created and where is
that destroid. Does C# come with a garbadge collection like Java, Ada and
Smalltalk. This problem is the main problem OOP using C++ since you have to
destroy the objects you create. What happens when you destroy (delete []
object) and then still have a referense that points (refers) to the deleted
object. (Oooops)

When it comes to data types and algoritms there is really no differense
between a referense and a pointer. Basicly it's the same thing although C++
mess up this for you with the use of pointers. It has to to be backward
compatible with C. The referense types (int&) in C++ is the same as (int&).
The following classes is not the same whenit comes to copy contructors and
default constructors.

class X {
private
   int* i;
}

class Y {
private
   int& i;
}

X x1(1);
X x2;
Y y1(2);
Y y2

x1=x2; // OK

y1=y2;  //  Compiler error ,canät generate default and copy condtructors.

What is the similar for this in C#? Can this code be wxecuted i C#?

Lars

OK...now suppose I have the following code:

<script runat="server">
   Class MyInt
       Public MyValue As Integer
   End Class

   Sub Page_Load(ByVal obj As Object, ByVal ea As EventArgs)
       Dim x As New MyInt

       ...................
       ...................
       ...................
   End Sub
</script>

If I am not wrong, the Dim line in the Page_Load sub "creates space in
the heap & returns a pointer (say, 0x000001)". To whom does the Dim
line return the pointer?

Please correct me if I am wrong.

no heap is used.

the variable x is on the stack and is the value, rather than reference
to the value. the variable MyValue being a class static value, is
allocated in the static class definition structure, and again is the
value, not a pointer to the value.

in .net numerics, bools, dates, structures and enums are value types,
everything else is a true object and thus a reference type.

-- bruce (sqlwork.com)

There seems to be some confusion in this thread with lots of references to
other languages and other mis-leading content.

You are correct the MyInt class is allocated off the heap.

The 'pointer'  (lets call it a reference shall we) returned by the New
operator is stored in the variable x.

If we did this:-

Dim y As MyInt

y = x

y would also reference the same instance of the MyInt held in heap.

Class types are always stored on the heap, period.

y.MyValue = 16

would result in x.MyValue also being 16 since both variables reference the
same object.

What if we had:-

Structure MyInt
   Public MyValue As Integer
   Publoc MyOtherValue as Integer
End Structure

In this case the symbol x represents space allocated from the stack to store
the MyInt structure, there is no heap allocation and no reference involved.

y = x

Would result in the content of x being copied to y and this:.

y.MyValue = 16

would not affect the MyValue member held in x.

Note that even single value types like Integer or Double are treated as
Structures.

IMO its better to ask 'Is it a Class or a Structure?' instead of 'Is it a
ValueType or a ReferenceType?'  Why?  See note 1 after sig, I don't want to
blur things to much here.

So to the original point;  is a string a class or a structure?  Ans:  It's a
class.
Therefore its always allocated in the heap and a variable of string type is
always a reference to this string object allocated on the heap.

Dim x As String = "Hello World"
Dim y As String
y = x

As with all classes in this case y and x both reference the same String
object.

What makes this less obvious (as Mykola alluded to) is the immutable nature
of a String. Once a string object has been allocated and initialised its
content cannot be changed, not even changes that don't involve changing the
length.  This results in code which makes strings look like they are
behaving as structures because no where do see an operation on one reference
that is visable through another reference.

A similar type to a string is a character array but a character array is
mutable :-

 Dim z As Char() = New Char(2) {"A"c, "B"c, "C"c}
 Dim x As Integer()

 x = z

 x(1) = "X"c

 Console.WriteLine(z(1))

Note that both z and x reference the same Array object.  A modification made
to the object via one reference is visible using the other.  This sort of
operation just isn't available on the string object.  Its the lack of this
sort of thing happening in code to a string which gives the illusion of it
being a structure.

However Mykola is in error stating that you can't pass strings as ByRef.
You can (in both VB and C#).

Public Sub DoSomething(ByRef rs As String)
   rs = "New content"
End Sub

Dim s as String = "Hello World"

DoSomething(s)

Console.WriteLine(s)

This confusion arises from the overloaded use of the word Reference (which
is why I prefer to think in terms of Structures or Classes).   When you
think about it all variables are ultimately references to somewhere in
memory where a value is stored.  For example:-

Sub Thing()
   Dim i as Integer
   Dim o as Object

The symbol i resolves to a offset pointer from the a fixed point on the
stack frame where 4 bytes hold the actual value of the integer.  The symbol
o resolves to an offset pointer (likely the same as for i + 4) from the same
fixed point on the stack frame which will hold a reference to some reference
to an object stored on the heap.

Passing ByRef has nothing to do with whether the value is a Structure or a
Class but everything to do with where relative to a fixed point on a stack
frame to find the variable value (be that the actual structure content or
the reference to a heap held object).  Since at the time of call the size of
the current frame is known its relatively simple to supply an offset from a
fixed point in the new frame back into the previous.