Does re-introducing the same literal value, of value type, in code instantiate the value type again?

Question

1.00/5 (1 vote)

See more:

The concept of string interning establishes that each time a unique string literal is introduced in code, reference type String is instantiated and a reference to that instance is stored in the intern pool. However, anytime a string literal (that was already introduced in code) is introduced in code again, a reference (retrieved from the intern pool) to the already existing instance is returned. Thus, no new instance of type String is created and no new reference is stored in the intern pool. In relevance to the bottom example, in line 1, type String is instantiated and a reference to the instance (stored in the intern pool) is assgined to variable str1. In line 2, type String is NOT instanstiated. Instead a reference to the already existing instance of type String` is assigned variable str2.

string str1 = "Fun"; // line 1
string str2 = "Fun"; // line 2

What about when dealing with a literal value of Value type (e.g. a bool literal, an int literal, a char literal). For example, what if I introduce the same literal value of Value type (in this case of type Int32) in code more than once. Will the Value type (in this case type Int32) be instantiated each time the same literal value of Value type is introduced in code?

In other words, in line 1, value type Int32 is instantiated. The literal value (instance of type Int32) is stored directly in the variable num1. In line 2 however, is Value type Int32 instantiated again or not?

int num1 = 78; // line 1
int num2 = 78; // line 2

P.S. I am aware that a variable of Value type directly stores that value assigned to it (not a referenced to value assigned to it).

What I have tried:

I am aware there are Microsoft documentation related to these topics but I have not found anywhere this is explicitly answer. C# language.

Posted 28-Oct-21 19:56pm

Chris_PBacon

Updated 28-Oct-21 21:35pm

Add a Solution

Comments

BillWoodruff 29-Oct-21 6:25am

once again you are posting a kind of semantic fantasia, where you pose as some kind of sophist disputing documentation.

if you want to learn C#, experiment, and observe behavior, and generate hypotheses, as well as study documentation.

imagine a carpenter that can tell you how a saw works, but, has never tried to use one.

1 solution

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)

OriginalGriff · Answer 1 · 2021-10-28T21:35:00

No in both cases.
The difference is that strings are reference types, int32 is a value type - and that's im portant, because neither of these lines strictly speaking instantiates anything - they create stack based variables and assign a value to them.

When you instantiate a reference type in a method

C#

void foo()
   {
   MyClass mc = new MyClass();
   }

The variable mc is also stack based, but the instance of the MyClass that is assigned is on the heap, and can be persisted beyond the method by assigning it to an external (class level) variable, or by returning it to the caller:

C#

MyClass MC;
void foo()
   {
   MyClass mc = new MyClass();
   ...
   MC = mc;
   }

C#

MyClass foo()
   {
   MyClass mc = new MyClass();
   ...
   return mc;
   }

in both cases, the variable mc ceases to exist when the method ends, but the heap based reference persists and can be used by other methods.

Value types are different: each time you use them, a copy is made so if we did this:

C#

int I;
void foo()
   {
   int i = 666;
   ...
   I = i;
   }

The value in both I and i would be the same - 666 - but they are not the same variable, so any change to one does not affect the other in any way:

C#

int I;
void foo()
   {
   int i = 666;
   ...
   I = i;
   i = i / 3;
   }

i and I now contain different values: 222 and 666 because they are value types.

So the answer to your question is "No" - because with value types no instantiation takes
place, so there is no interning either. Generally speaking, the "literal value" of a value type is stored directly in the IL code which constructs and initializes the variable.

And strings are a special case: they intern because they are immutable, not because they are reference types - no other reference type interns!