passing address of a structure array to a variable

Question

2.00/5 (2 votes)

See more:

C#

C#4.0

hi....,
how can i pass address of a structure to a variable?? is it possible in c#??
byte b=&array[0]; is it possible??

Posted 12-Aug-14 18:07pm

Member 10994712

Add a Solution

Comments

Sergey Alexandrovich Kryukov 13-Aug-14 1:08am

If sounds like "C thinking". You need to go beyond that, to understand things. Why address? Do you understand that managed pointers (references) are not fixed (there is a procedure of pinning, used in really rare cases)? they are managed.
—SA

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

Sergey Alexandrovich Kryukov · Answer 1 · 2014-08-12T19:28:00

Please see my comment to the question. You intention is not explained, so I can only guess that this is the sign of "C thinking". (Not just C, but I hope you understand what I mean.)

Without understanding of your problems, it's hard to advise anything certain, but I'll try to make some hints. First thing you need to understand is that the address of the instance of some structure is needed not for itself, but for accessing the structure. Second thing: you need to know how reference types work (heap is always involved), in contrast to value types which only appear on heap be being used in some reference type. The structures are value types. Therefore, they are copied memberwise when assigned. So, perhaps another thing to understand is by-value and by-reference parameter passing. Compare:

C#

internal struct SomeValueType {
    // usually fields are private,
    // but, for example:
    internal int SomeMember; 
    internal SomeValueType(int someMember) { SomeMember = someMember; /*...*/ }
    // ...
}

// ...

void ByValue(SomeValueType someParameter) {
    // this is a copy of a parameter put on stack:
    ++someParameter.SomeMember; // will not affect the actual parameter 
    // ...
} 

void ByRef(ref SomeValueType someParameter) { // reference is passed
    ++someParameter.SomeMember; // will not affect the actual parameter 
    // ...
}

void ByRefOut(out SomeValueType someParameter) {
    someParameter = new SomeValueType(13); // it is required to initialize the parameter
}


//...

SomeValueType myInstance = new SomeValueType(3);
ByValue(myInstance); // now myInstance.SomeMember is 3, not 4!
ByRef(myInstance); // now myInstance.SomeMember is 4
ByRefOut(myInstance); // referential identity of myInstance 
// and previous myInstance object is broken:
// now this is a brand-new object

There are a lot more situations where you need to understand well what happens to the reference to some object on heap, stack and static memory area; you need to understand static and instance members, and a lot more. And you need to understand that managed pointers are not directly bound to physical (and not even to virtual) addresses core OS works with: they can be relocated in consistent manner, so in each point of the code the references keep pointing to the same objects, but the objects themselves can move around in memory space. This is one of the reason for unsafe and pinning (read about it).

I hope it can give you some insight.

—SA

OriginalGriff · Answer 2 · 2014-08-12T19:03:00

Well...not like that: that wouldn't work in any language, since a byte variable can't hold the address of anything - they are only 8 bits, and addresses these days are at least 32.

And there is a problem here in that an array isn't a structure at all, it's always a class (and so a reference type), even if the datatype it is an array of are value types.

You can get the address of things in C#, but you need to use unsafe code and pointers. which is:
A) Deliberatley difficult to do
B) Dangerous - which is why it's called unsafe code.

Under normal circumstances you don't need pointers or addresses in C#: the CLR and references take care of all that for you.

What are you trying to do that you think you need this?

"i need array[0]'s address"

It doesn't really have one.
Well...it does...but it moves...
The problem is that an array is a reference type, which means the whole array is located on the managed heap - which means that the Garbage Collector (which you have no control of, or idea of when it runs) is at liberty to move it at any time.
So if you do manage to get the actual "physical memory" address of the first element in the array, it could be invalid by the time you actually use it - even if that is the next instruction in your code. Now, there are ways round that, but it's unusual, and somewhat dangerous.

You can get a reference of the first element in the array - if it's a reference type - very easily:

C#

string[] array = new string[10];
for (int i = 0; i < 10; i++)
   array[i] = string.Format("Element {0}", i);
...
string s = array[0];

Why are you trying to get the address of anything? what are you planning on doing with it when you have it? Because I can't help thinking there is something missing here...

passing address of a structure array to a variable

2 solutions

Solution 2

Solution 1

Add your solution here

Preview 0