error while assigning object of type to element of reference

Prashant Jadhav

hi guys i was trying to create an class which contain array of reference type
and i was trying to assign same type object to the array element but it was showng me some errors i dont know where i am doing wrong that code is as follow please check it out and tell me where i did wrong

using System;
namespace EnumExpl
{
class employee
{
public string firstname;
public string lastname;
}
class employees
{

employee prashant=new employee()
{
firstname="prashant",
lastname="jadhav"

};
employee prakash=new employee()
{
firstname="prakash",
lastname="jadhav"

};
public employee[] Empl = new employee[2];
Empl[0]=prashant;

}
class Program
{
static void Main(string[] args)
{
}
}

}

Error1Array size cannot be specified in a variable declaration (try initializing with a 'new' expression)c:\users\prashant\documents\visual studio 2010\Projects\enumarator\enumarator\Program.cs2714enumarator

Error2Invalid token '=' in class, struct, or interface member declarationc:\users\prashant\documents\visual studio 2010\Projects\enumarator\enumarator\Program.cs2716enumarator

Error3Invalid token ';' in class, struct, or interface member declarationc:\users\prashant\documents\visual studio 2010\Projects\enumarator\enumarator\Program.cs2725enumarator

these are those error messege i was getting

9 Replies

Know the answer? Post it — somebody with the same question will find it here.

Vulpes12y ago
It means that, to all intents and purposes, the object already exists before the code in the constructor even runs. Its memory has been allocated and it's fields, including inherited fields, have been given a value even if it's only a default value.

However, the constructor code may provide further initialization of the object's fields where this cannot conveniently be done where the fields are defined.
+1
Prashant Jadhav12y ago
it mean constructor only use for creating memory for object in heap
it does not have relation with creating object instance with respective of their field and their values .
0
Vulpes12y ago
Yes, they could have allowed instance field initializers to reference each other because they would already have been given a default value.

Even if it is confusing, it seems illogical to allow it for static fields but not for instance fields.

To my knowledge, there is no official explanation for this state of affairs.

The only one I can offer is that instance field initializers would potentially be even more confusing than static field initializers because the former could involve fields inherited from base classes which had been initialized by base constructors called from the current class and could also call or rely on virtual methods which can't be resolved until runtime.

Whatever the reason, that's the way the language has been designed and it's very unlikely to be changed now.

Constructors are strange beasts and are not ideally named - initializers would have been a better name.

It's the 'new' operator which allocates the memory for the object on the heap and before the code in the constructor actually executes happens several other things happen:

1. All the object's fields are initialized to their default values.

2. If there are any field initializers, these are then executed.

3. The base class constructor is called either explicitly or implicitly (if there's no :base() clause specified) which causes the base class fields to be initialized first.

4. The constructors for the base class's ancestor classes are called in turn (up to and including System.Object) and the fields for those classes are first initialized.

5. The actual code in the constructors is now executed starting from System.Object (which has no code!) and ending with the current class.

So by the time the constructor code in the current class actually runs, all its fields (inherited or not) have been given some value (even if it's not the final one) and the object, to all intents and purposes, has been created which is why there is no limitation on it being able to access its own instance members.
0
Prashant Jadhav12y ago
hi vulpes
yes vulpes its weird.it means even x is static member they are allowing it default value to get assign to other static member of that class and according to this rule default values os instance variable should be allowed to get assign to other instance field
guide me if i am taking senseless

static public y=x <---if this is giving 0 value to y
static public x=5

then why not
public x=5
public y=x <----- this gives y 0 value

since even before object is created every fields value is initialized to 0
and why the execution is get stop here just because that same object of x variable is not created

and my another question is

how can we reference non static field value to other non static field in constructor
even when object does not get created before constructor does not get execute completely

as you replied

in this same post

However, you can of course do it at method level and so, if you add this constructor and put the line in there, it will work fine:

public employees()
{
Empl[0]=prashant;
}

i mean both instance fields belongs to same instance of class then how can we assign prashant which is instance member of object to empl[0] instance member of same object untill the whole constructor is not executed it mean that object it self is not created
0
Vulpes12y ago
Yes, I think you've grasped it now, Prashant :)

For completeness, I'll mention one other thing which I personally find rather odd.

Although instance field initializers can't reference other instance members, static field initializers can reference other static members of the same class!

So this works fine:

static int x = 5;
static int y = x;

and 'y' is initialized to 5.

However, if you do it the other way around:

static int y = x;
static int x = 5;

then 'y' is initialized to 0!

The reason is that all fields are first intialized to their default values (0 for numbers) before any explicit initializers run. So, then 'y' is explicitly initialized, 'x' is still 0 and so 'y' is (re)initialized to '0' as well.

To me this is just as confusing as if instance fields were allowed to use each other in their initializers and so I don't really know why they decided to allow it. It may be because you don't have to worry about such things as calling base constructors and virtual methods when dealing with static members and so the opportunities for unexpected behavior are reduced but I've never been able to find any explanation for the difference in treatment - even in the C# specification.

0
Prashant Jadhav12y ago
thank you so much vulpes
it mean since whole object is not been created at the time while we are trying to initialize non static member of same object ('this') so it is not allowed to use instance field value of same object for initializing other instance fields.
0
Vulpes12y ago
That's right. The second declaration wouldn't be allowed at class level because you're attempting to initialize 'y' with another instance field, 'x' of the same class:

int x=5;
int y=x;

The basic rule is that an instance field initializer cannot reference the instance being created (i.e. 'this').

So it can't reference any other instance fields of the current instance. Nor can it reference any methods or properties of the current instance and so this wouldn't be allowed either:

int x=5;
int y=GetX(); // error

public int GetX()
{
return x;
}

The reason for this rule is that, whilst the fields are being initialized (which occurs in textual order), the instance is not considered to have been fully created and you could get some odd results if it were allowed

However, there's nothing to stop you using static members of the same class to initialize an instance field. So this is OK:

static int s = 3;
int x=5;
int y=s; // OK because 's' is static

The point here is that static fields will always have been initialized before any instance fields and so allowing this doesn't cause any problems.

Incidentally, none of this is obvious and so this certainly isn't a stupid question, it's a good one :)

0
Prashant Jadhav12y ago
thank you vulpes for replying
it means even
int x=5;
int y=x;
wont be possible in class level
does it mean we can not use any other instance field value to instantiate other instance fields of same type.even when the value we need is equivalent.
and please guide me the way i was thinking was stupid or people may misunderstood in such way.
0
Vulpes12y ago
The problem lies with this line:

Empl[0]=prashant;

If you remove it, the program will compile OK.

The reason for the error is that you're not allowed to assign values to individual array elements at class level.

However, you can of course do it at method level and so, if you add this constructor and put the line in there, it will work fine:

public employees()
{
Empl[0]=prashant;
}

Incidentally, you're not allowed to do this either:

public employee[] Empl = new employee[2]{prashant, prakash};

The reason this time is that you can't reference other fields when initializing the array at class level.
0