Detailed explanation of data type conversion (packing and unboxing) and constants

Implicit conversion [automatic type conversion]:

The two types must be compatible, and the original type value range must be smaller than the target type value range. It can be simply understood as turning from small to large.

public class Test
{
  private void Start()
  {
    int a = 10;
    float b = a;//Int type is implicitly converted to float type  }
}

Show conversion [Capt]:

The two types must be compatible, and the original type value range must be larger than the target type value range. It can be simply understood as turning from large to small.

[Disadvantages]: 1. Data overflow. 2. Accuracy is lost.

Conversion between numeric types.

public class Test
{
  private void Start()
  {
    float a = 1.5f;
    int b = (int)a;//Float type cast to int type  }
}

Convert other types to string types to call the ToString() method.

public class Test
{
   private void Start()
   {
     float a = 1.5f;
     bool val = true;
     string str = ();//bool type cast to string type     str = ();//Float type cast to string type   }
}

Convert string types to other basic types to call the Parse() method and the TryParse() method.

public class Test
{
  private void Start()
  {
    string str = "true";
    bool v = (str);//If the conversion is successful, the value will be assigned to the variable v, and if the conversion is unsuccessful, an error will be reported.    int num;
    bool val = (str, out num);//A bool value will be returned regardless of success or not.  If the conversion is successful, the value will be assigned to the variable num.  }
}

Convert to convert between other basic types. (Using Convert requires reference to using System assembly)

using UnityEngine;
using System;

public class Test
{
  private void Start()
  {
    bool val = false;
    int num = Convert.ToInt32(val);
    int a = 0;
    bool v = (a);
  }
}

Box: Convert value type to reference type.

Unboxing: Convert the reference type to a value type.

Notice:

1. Packing or unboxing operations can occur only when there is an inheritance relationship between the two types.

2. Packing and unboxing are essentially changes in data storage between stack space and heap space. Therefore, frequent packing or unboxing will reduce operational efficiency, so try to use packing or unboxing operations as little as possible in the code.

constant:A constant that cannot be changed can not be reassigned once it is declared.

Naming rules:The naming of constant names is generally capitalized, and the words are separated by underscores (example: SERVER_IP).

Declaration of constants:The keyword const needs to be added and must be assigned at declaration time. (Example: const int SERVER_IP;)

The above detailed explanation of data type conversion (packing and unboxing) and constants is all the content I share with you. I hope you can give you a reference and I hope you can support me more.