返回顶部
首页 > 资讯 > 精选 >C#中的数组怎么使用
  • 255
分享到

C#中的数组怎么使用

2023-06-30 00:06:28 255人浏览 薄情痞子
摘要

今天小编给大家分享一下C#中的数组怎么使用的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。如果需要使用同一类型的多个对象,可以

今天小编给大家分享一下C#中的数组怎么使用的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。

    如果需要使用同一类型的多个对象,可以使用数组和集合(后面介绍)。C#用特殊的记号声明,初始化和使用数组。Array类在后台发挥作用,它为数组中的元素排序和过滤提供了多个方法。使用枚举器,可以迭代数组中的所有元素。
    如果需要使用不同类型的多个对象,可以使用Tuple(元组)类型。

    一.简单数组(一维数组)

    数组是一种数据结构,它可以包含同一个类型的多个元素。

    1.数组的声明

    在声明数组时,先定义数组中的元素类型,其后是一对空方括号和一个变量名。

    int[] myArray;

    2.数组的初始化

    声明了数组之后,就必须为数组分配内存,以保存数组的所有元素。数组是引用类型,所以必须给它分配堆上的内存。为此,应使用new运算符,指定数组中元素的类型和数量来初始化数组的变量。

    myArray = new int[4];

    在声明和初始化数组后,变量myArray就引用了4个整数值,它们位于托管堆上:

    C#中的数组怎么使用

    在指定了数组的大小后,就不能重新设置数组的大小。如果事先不知道数组中应包含多少个元素,就可以使用集合。
    除了在两个语句中声明和初始化数组之外,还可以在一个语句中声明和初始化数组:

    int[] myArray = new int[4];

    还可以使用数组初始化器为数组的每个元素复制。数组初始化器只能在声明数组变量时使用,不能在声明数组之后使用。

    int[] myArray = new int[4]{1,3,5,7};

    如果用花括号初始化数组,可以不指定数组的大小,因为编译器会自动统计元素的个数:

    int[] myArray = new int[]{1,3,5,7};

    也可以使用更简单的形式:

    int[] myArray = {1,3,5,7};

    3.访问数组元素

    在声明和初始化数组之后,就可以使用索引器访问其中的元素了。数组只支持有整型参数的索引器。
    索引器总是以0开头,表示第一个元素。可以传递给索引器的最大值是元素个数减1,因为索引从0开始:

    int[] myArray = {1,3,5,7};int v1 = myArray[0];int v2 = myArray[1];myArray[3] = 4;

    可以使用数组的Length属性获取元素的个数。

    4.数组中使用引用类型

    数组除了能声明预定义类型的数组,还可以声明自定义类型的数组。

      public class Person  {    public string FirstName { get; set; }    public string LastName { get; set; }    public override string ToString()    {      return String.FORMat("{0} {1}", FirstName, LastName);    }  }  Person[] myPersons = new Person[2];  myPersons[0] = new Person { FirstName = "Ayrton", LastName = "Senna" };  myPersons[1] = new Person { FirstName = "Michael", LastName = "SchuMacher" };

    如果数组中的元素是引用类型,就必须为每个数组元素分配内存。如果使用了数组中未分配内存的元素,就会抛出NullReferenceException类型的异常。
    下面是内存情况:

    C#中的数组怎么使用

    对自定义类型也可以使用数组初始化器:

      Person[] myPersons2 =  {    new Person { FirstName="Ayrton", LastName="Senna"},    new Person { FirstName="Michael", LastName="Schumacher"}  };

    二.多维数组

    多维数组用两个或多个整数来索引。
    在C#中声明多维数组,需要在方括号中加上逗号。数组在初始化时应指定每一维的大小(也称为阶)。

    int[,] twoDim = new int[3,3];twoDim[0,0] = 1;twoDim[0,1] = 2;twoDim[0,2] = 3;twoDim[1,0] = 4;twoDim[1,1] = 5;twoDim[1,2] = 6;twoDim[2,0] = 7;twoDim[2,1] = 8;twoDim[2,2] = 9;

    声明数组之后,就不能修改其阶数了。
    也可以使用初始化器来初始化多维数组:

      int[,] twoDim ={    {1,2,3},    {4,5,6},    {7,8,9}    };

    使用数组初始化器时,必须初始化数组的每个元素,不能遗漏任何元素。
    声明一个三位数组:

      int[,,] threeDim ={    {{1,2},{3,4}},    {{5,6},{7,8}},    {{9,10},{11,12}}    };  Console.WriteLine(threeDim[0,1,1]);

    三.锯齿数组

    二维数组的大小对应于一个矩形,而锯齿数组的大小设置比较灵活,在锯齿数组中,每一行都可以有不同的大小。
    在声明锯齿数组时,要依次放置左右括号。在初始化锯齿数组时,只在第一对方括号中设置该数组包含的行数。定义各行中元素个数的第二个方括号设置为空,因为这类数组的每一行包含不同的元素个数。之后,为每一行指定行中的元素个数:

      int[][] jagged = new int[3][];  jagged[0] = new int[2]{1,2};  jagged[1] = new int[4]{3,4,5,6};  jagged[2] = new int[3]{7,8};

    迭代锯齿数组中的所有元素的代码可以放在嵌套的for循环中。在外层的for循环中迭代每一行,在内层的for循环中迭代一行中的每个元素:

      for(int row = 0;row<jagged.Length;row++)  {    for(int element = 0;element<jagged[row].Length;element++)    {      Console.WriteLine("row:{0}, element:{1},value:{2}",row,element,jagged[row][element]);    }  }

    四.Array类

    用方括号声明数组是C#中使用Array类的表示法。在后台使用C#语法,会创建一个派生自抽象基类Array的新类。这样,就可以使用Array类为每个C#数组定义的方法和属性了。
    Array类实现的其它属性有LongLength和Rank。如果数组包含的元素个数超出了整数的取值范围,就可以使用LongLength属性来获得元素个数。使用Rank属性可以获得数组的维数。

    1.创建数组

    Array类是一个抽象类,所以不能使用构造函数来创建数组。但除了使用C#语法创建数组实例之外,还可以使用静态方法CreateInstance()创建数组。如果事先不知道元素的类型,该静态方法就很有用,因为类型可以作为Type对象传递给CreateInstance()方法。
    CreateInstance()方法的第一个参数是元素的类型,第二个参数定义数组的大小。
    可以使用SetValue()方法设置对应元素的值,用GetValue()方法读取对应元素的值。

      Array intArray1 = Array.CreateInstance(typeof(int), 5);  for (int i = 0; i < 5; i++)  {    intArray1.SetValue(33, i);  }  for (int i = 0; i < 5; i++)  {    Console.WriteLine(intArray1.GetValue(i));  }

    还可以将已经创建的数组强制转换称声明为int[]的数组:

    int[] intArray2 = (int[])intArray1;

    CreateInstance()方法有许多重载版本,可以创建多维数组和索引不基于0的数组。

      //创建一个2X3的二维数组,第一维基于1,第二维基于10:  int[] lengths = { 2, 3 };  int[] lowerBounds = { 1, 10 };  Array racers = Array.CreateInstance(typeof(Person), lengths, lowerBounds);  racers.SetValue(new Person { FirstName = "Alain", LastName = "Prost" }, index1: 1, index2: 10);  racers.SetValue(new Person  {    FirstName = "Emerson",    LastName = "Fittipaldi"  }, 1, 11);  racers.SetValue(new Person { FirstName = "Ayrton", LastName = "Senna" }, 1, 12);  racers.SetValue(new Person { FirstName = "Michael", LastName = "Schumacher" }, 2, 10);  racers.SetValue(new Person { FirstName = "Fernando", LastName = "Alonso" }, 2, 11);  racers.SetValue(new Person { FirstName = "Jenson", LastName = "Button" }, 2, 12);  Person[,] racers2 = (Person[,])racers;  Person first = racers2[1, 10];  Person last = racers2[2, 12];

    2.复制数组

    因为数组是引用类型,所以将一个数组变量赋予另一个数组变量,就会得到两个引用同一数组的变量。
    数组实现ICloneable接口。这个接口定义的Clone()方法会复制数组,创建数组的浅表副本。
    如果数组的元素是值类型,Clone()方法会复制所有值:

      int[] a1 = {1,2};  int[] a2 = (int[])a1.Clone();

    如果数组包含引用类型,只复制引用。
    除了使用Clone()方法之外,还可以使用Array.Copy()方法创建浅表副本。

      Person[] beatles = {    new Person { FirstName="John", LastName="Lennon" },    new Person { FirstName="Paul", LastName="McCartney" }  };  Person[] beatlesClone = (Person[])beatles.Clone();  Person[] beatlesClone2 = new Person[2];  Array.Copy(beatlesClone,beatlesClone2,2);//注意与Clone的语法区别,Copy需要传递阶数相同的已有数组。(还可以使用CopyTo()方法)

    3.排序

    Array类使用快速排序算法对数组中的元素进行排序。Sort()方法需要数组中的元素实现IComparable接口。因为简单类型(如String,Int32)实现IComparable接口,所以可以对包含这些类型的元素排序。

        string[] names = {    "Christina Aguilera",    "Shakira",    "Beyonce",    "Gwen Stefani"    };    Array.Sort(names);    foreach (string name in names)    {      Console.WriteLine(name);    }

    如果对数组使用使用自定义类,就必须实现IComparable接口。这个接口只定义了一个方法CompareTo()方法,如果要比较的对象相等,该方法就返回0.如果该实例应排在参数对象的前面,该方法就返回小于i0de值。如果该实例应排在参数对象的后面,该方法就返回大于0的值。

      public class Person : IComparable<Person>  {    public string FirstName { get; set; }    public string LastName { get; set; }    public override string ToString()    {      return String.Format("{0} {1}",      FirstName, LastName);    }    public int CompareTo(Person other)    {      if (other == null) throw new ArgumentNullException("other");      int result = this.LastName.CompareTo(other.LastName);      if (result == 0)      {        result = this.FirstName.CompareTo(other.FirstName);      }      return result;    }  }

    客户端代码:

      Person[] persons = {  new Person { FirstName="Damon", LastName="Hill" },  new Person { FirstName="Niki", LastName="Lauda" },  new Person { FirstName="Ayrton", LastName="Senna" },  new Person { FirstName="Graham", LastName="Hill" }  };  Array.Sort(persons);  foreach (Person p in persons)  {    Console.WriteLine(p);  }

    如果Person对象的排序方式与上述不同,或者不能修改在数组中用作元素的类,就可以实现IComparer接口或IComparer<T>接口。这两个接口定义了方法Compare()方法。机型比较的类必须实现这两个接口之一。

      public enum PersonCompareType  {    FirstName,    LastName  }  //通过使用实现了IComparer<T> 泛型接口的PersonComparer类比较Person对象数组。  public class PersonComparer : IComparer<Person>  {    private PersonCompareType compareType;    public PersonComparer(PersonCompareType compareType)    {      this.compareType = compareType;    }    #region IComparer<Person> Members    public int Compare(Person x, Person y)    {        if (x == null) throw new ArgumentNullException("x");        if (y == null) throw new ArgumentNullException("y");      switch (compareType)      {        case PersonCompareType.FirstName:          return x.FirstName.CompareTo(y.FirstName);        case PersonCompareType.LastName:          return x.LastName.CompareTo(y.LastName);        default:          throw new ArgumentException(          "unexpected compare type");      }    }    #endregion  }

    客户端代码:

      Person[] persons = {  new Person { FirstName="Damon", LastName="Hill" },  new Person { FirstName="Niki", LastName="Lauda" },  new Person { FirstName="Ayrton", LastName="Senna" },  new Person { FirstName="Graham", LastName="Hill" }  };  Array.Sort(persons,  new PersonComparer(PersonCompareType.FirstName));  foreach (Person p in persons)  {    Console.WriteLine(p);  }

    五.数组作为参数

    数组可以作为参数传递给方法,也可以从方法中返回。

    1.数组协变

    数组支持协变。这表示数组可以声明为基类,其派生类型的元素可以赋值于数组元素。

      static void DisPlay(object[] o)  {    //..  }

    可以给该方法传递一个Person[]。
    数组协变只能用于引用类型,不能用于值类型。

    2.ArraySegment<T>

    结构ArraySegment<T>表示数组的一段。如果需要使用不同的方法处理某个大型数组的不同部分,那么可以把相应的数组部分复制到各个方法。
    ArraySegment<T>结构包含了关于数组段的信息(偏移量和元素个数)。

      static void Main()  {    int[] ar1 = { 1, 4, 5, 11, 13, 18 };    int[] ar2 = { 3, 4, 5, 18, 21, 27, 33 };    var segments = new ArraySegment<int>[2]    {      new ArraySegment<int>(ar1, 0, 3),      new ArraySegment<int>(ar2, 3, 3)    };    var sum = SumOfSegments(segments);    Console.WriteLine("sum of all segments: {0}", sum);  }  static int SumOfSegments(ArraySegment<int>[] segments)  {  int sum = 0;  foreach (var segment in segments)  {    for (int i = segment.Offset; i < segment.Offset + segment.Count; i++)    {        sum += segment.Array[i];    }  }  return sum;  }

    数组段不复制原数组的元素,但原数组可以通过ArraySegment<T>访问。如果数组段中的元素改变了,这些变化就会反映到原数组中。

    六.枚举集合

    在foreach语句中使用枚举,可以迭代集合中的元素,且无需知道集合中元素的个数。foreach语句使用一个枚举器。foreach会调用实现了IEnumerable接口的集合类中的GetEumerator()方法。GetEumerator()方法返回一个实现IEnumerator接口的对象枚举。foreach语句就可以使用IEnumerable接口迭代集合了。
    GetEumerator()方法在IEnumerable接口中定义。

    1.IEnumerator接口

    foreach语句使用IEnumerator接口的方法和属性,迭代集合中所有元素。IEnumerator接口定义了Current属性,来返回光标所在的元素,该接口的MoveNext()方法移动到集合的下一个元素上,如果有这个元素,该方法就返回true。如果集合不再有更多的元素,该方法就返回false.
    这个接口的泛型版本IEnumerator<T>派生自接口IDisposable,因此定义了Dispose()方法,来清理枚举器占用的资源。

    2.foreach语句

    C#中foreach语句不会解析为IL代码中的foreach语句。C#编译器会把foreach语句转换为IEnumerator接口的方法和属性。

      Person[] persons = {    new Person { FirstName="Damon", LastName="Hill" },    new Person { FirstName="Niki", LastName="Lauda" },    new Person { FirstName="Ayrton", LastName="Senna" },    new Person { FirstName="Graham", LastName="Hill" }  };  foreach (Person p in persons)  {    Console.WriteLine(p);  }

    foreach语句会解析为下面的代码:

      IEnumerator<Person> enumerator = persons.GetEumerator();  while(enumerator.MoveNext())  {    Person p = enumerator.Current;    Console.WriteLine(p);  }

    3.yield语句

    在C#2.0之前,foreach语句可以轻松的迭代集合,但创建枚举器需要做大量的工作。C#2.0添加了yield语句,以便创建枚举器。
    yield return 语句返回集合的一个元素,并移动到下一个元素。yield break可停止迭代。
    下面的例子实现返回两个字符串

      public class HelloCollection  {    public IEnumerator<string> GetEnumerator()    {    yield return "Hello";    yield return "World";    }  }

    客户端代码:

      var helloCollection = new HelloCollection();  foreach (string s in helloCollection)  {    Console.WriteLine(s);  }

    包含yield语句的方法或属性也称为迭代块。迭代块必须声明为返回IEnumerator或IEnumerable接口,或者这些接口的泛型版本。这个块可以包含多条yield return语句或yield break语句,但不能包含return语句。
    使用迭代块,编译器会生成一个yield类型,其中包含一个状态机,如下面代码所示:
    yield类型实现IEnumerator和IDisposable接口的方法和属性。下面的例子可以把yield类型看作内部类Enumerator。外部类的GetEnumerator()方法实例化并返回一个新的yield类型。在yield类型中,变量state定义了迭代的当前位置,每次调用MoveNext()时,当前位置都会改变。MoveNext()封装了迭代块的代码,并设置了current变量的值,从而使Current属性根据位置返回一个对象。

      public class HelloCollection  {    public IEnumerator<string> GetEnumerator()    {      return new Enumerator(0);    }  public class Enumerator:IEnumerator<string>,IEnumerator,IDisposable  {    private int state;    private string current;    public Enumerator(int state)    {      this.state = state;    }    bool System.Collections.IEnumerator.MoveNext()    {      switch(state)      {        case 0:          current="hello";          state =1;          return true;        case 1:          current="world";          state =2;          return true;        case 2:          break;      }      return false;    }    void System.Collection>IEnumerator.Reset()    {      throw new NotSupportedException();    }    string System.Collections.Generic.IEnumerator<string>.Current    {      get      {        return current;      }    }    object System.Collections.IEnumerator.Current    {      get      {        return current;      }    }    void IDisposable.Dispose()    {}  }}

    yield语句会产生一个枚举器,而不仅仅生成一个包含的项的列表。这个枚举器通过foreach语句调用。从foreach中依次访问每一项,就会访问枚举器。这样就可以迭代大量的数据,而无需一次把所有的数据都读入内存。

    (1).迭代集合的不同方式

    可以使用yield return语句,以不同方式迭代集合。
    类MusicTitles可以用默认方式通过GetEnumerator()方法迭代标题,该方法不必在代码中编写,也可以用Reverse()逆序迭代标题,用Subset()方法迭代子集合:

        public class MusicTitles    {      string[] names = {      "Tubular Bells", "Hergest Ridge",      "Ommadawn", "Platinum" };      public IEnumerator<string> GetEnumerator()      {        for (int i = 0; i < 4; i++)        {          yield return names[i];        }      }      public IEnumerable<string> Reverse()      {        for (int i = 3; i >= 0; i--)        {          yield return names[i];        }      }      public IEnumerable<string> Subset(int index, int length)      {        for (int i = index; i < index + length;i++)        {          yield return names[i];        }      }    }

    客户端代码:

        var titles = new MusicTitles();    foreach (var title in titles)    {      Console.WriteLine(title);    }    Console.WriteLine();    Console.WriteLine("reverse");    foreach (var title in titles.Reverse())    {      Console.WriteLine(title);    }    Console.WriteLine();    Console.WriteLine("subset");    foreach (var title in titles.Subset(2, 2))    {      Console.WriteLine(title);    }
    (2).用yield return 返回枚举器
    public class GameMoves  {    private IEnumerator cross;    private IEnumerator circle;    public GameMoves()    {      cross = Cross();      circle = Circle();    }    private int move = 0;    const int MaxMoves = 9;    public IEnumerator Cross()    {      while (true)      {        Console.WriteLine("Cross, move {0}", move);        if (++move >= MaxMoves)          yield break;        yield return circle;      }    }    public IEnumerator Circle()    {      while (true)      {        Console.WriteLine("Circle, move {0}", move);        if (++move >= MaxMoves)          yield break;        yield return cross;      }    }  }

    客户端代码:

        var game = new GameMoves();    IEnumerator enumerator = game.Cross();    while (enumerator.MoveNext())    {      enumerator = enumerator.Current as IEnumerator;    }

    这样会交替调用Cross()和Circle()方法。

    七.元组(Tuple)

    元组可以合并不同类型的对象。元组起源于函数编程语言,如F#。在.net Framework中,元组可用于所有的.Net语言。
    .NET Framework定义了8个泛型Tuple类和一个静态Tuple类,它们用作元组的工厂。不同的泛型Tuple类支持不同数量的元素。如,Tuple<T1>包含一个元素,Tuple<T1,T2>包含两个元素。

    Tuple<string, string> name = new Tuple<string, string>("Jochen", "Rindt");

    元组也可以用静态Tuple类的静态Create()方法创建。Create()方法的泛型参数定了要实例化的元组类型:

      public static Tuple<int, int> Divide(int dividend, int divisor)  {    int result = dividend / divisor;    int reminder = dividend % divisor;    return Tuple.Create<int, int>(result, reminder);  }

    可以用属性Item1和Item2访问元组的项:

      var result = Divide(5, 2);  Console.WriteLine("result of division: {0}, reminder: {1}", result.Item1, result.Item2);

    如果元组包含的项超过8个,就可以使用带8个参数的Tuple类定义。最后一个模板参数是TRest,表示必须给它传递一个元组。这样,就可以创建带任意个参数的元组了。
     

      var tuple = Tuple.Create<string, string, string, int, int, int, double, Tuple<int, int>>(  "Stephanie", "Alina", "Nagel", 2009, 6, 2, 1.37, Tuple.Create<int, int>(52, 3490));

    八.结构比较

    数组和元组都实现接口IStructuralEquatable和IStructuralComparable。这两个接口不仅可以比较引用,还可以比较内容。这些接口都是显式实现的,所以在使用时需要把数组和元组强制转换为这个接口。
    IStructuralEquatable接口用于比较两个元组或数组是否有相同的内同,IStructuralComparable接口用于给元组或数组排序。
    IStructuralEquatable接口示例:
    编写实现IEquatable接口的Person类,IEquatable接口定义了一个强类型化的Equals()方法,比较FirstName和LastName的值:

    public class Person : IEquatable<Person>  {    public int Id { get; private set; }    public string FirstName { get; set; }    public string LastName { get; set; }    public override string ToString()    {      return String.Format("{0}, {1} {2}", Id, FirstName, LastName);    }    public override bool Equals(object obj)    {        if (obj == null)            return base.Equals(obj);        return Equals(obj as Person);    }    public override int GetHashCode()    {        return Id.GetHashCode();    }    #region IEquatable<Person> Members    public bool Equals(Person other)    {      if (other == null)        return base.Equals(other);      return this.FirstName == other.FirstName && this.LastName == other.LastName;    }    #endregion  }

    创建两个包含相同内容的Person类型的数组:

      var janet = new Person { FirstName = "Janet", LastName = "Jackson" };  Person[] persons1 = { new Person { FirstName = "Michael", LastName = "Jackson" }, janet };  Person[] persons2 = { new Person { FirstName = "Michael", LastName = "Jackson" }, janet };

    由于两个变量引用两个不同数组,所以!=返回True:

      if (persons1 != persons2)    Console.WriteLine("not the same reference");

    对于IStructuralEquatable接口定义的Equals方法,第一个参数是object类型,第二个参数是IEqualityComparer类型。调用这个方法时,通过传递一个实现了EqualityComparer<T>的对象,就可以定义如何进行比较。通过EqualityComparer<T>类完成IEqualityComparer的一个默认实现。这个实现检查T类型是否实现了IEquatable接口,并调用IEquatable.Equals()方法。如果该类没有实现IEquatable接口,就调用Object基类中Equals()方法:

      if ((persons1 as IStructuralEquatable).Equals(persons2, EqualityComparer<Person>.Default))  {    Console.WriteLine("the same content");  }

    元组示例:
    Tuple<>类提供了两个Epuals()方法:一个重写了Object基类中的Epuals方法,并把object作为参数,第二个由IStructuralEquatable接口定义,并把object和IEqualityComparer作为参数。

      var t1 = Tuple.Create<int, string>(1, "Stephanie");  var t2 = Tuple.Create<int, string>(1, "Stephanie");  if (t1 != t2)  Console.WriteLine("not the same reference to the tuple");

    这个方法使用EqualityComparer<object>.Default获取一个ObjectEqualityComparer<object>,以进行比较。这样就会调用Object.Equals()方法比较元组的每一项:

      if (t1.Equals(t2))    Console.WriteLine("equals returns true");

    还可以使用TupleComparer类创建一个自定义的IEqualityComparer

      TupleComparer tc = new TupleComparer();  if ((t1 as IStructuralEquatable).Equals(t2, tc))  {    Console.WriteLine("yes, using TubpleComparer");  }  class TupleComparer : IEqualityComparer  {    #region IEqualityComparer Members    public new bool Equals(object x, object y)    {      bool result = x.Equals(y);      return result;    }    public int GetHashCode(object obj)    {      return obj.GetHashCode();    }    #endregion  }

    以上就是“C#中的数组怎么使用”这篇文章的所有内容,感谢各位的阅读!相信大家阅读完这篇文章都有很大的收获,小编每天都会为大家更新不同的知识,如果还想学习更多的知识,请关注编程网精选频道。

    --结束END--

    本文标题: C#中的数组怎么使用

    本文链接: https://www.lsjlt.com/news/326811.html(转载时请注明来源链接)

    有问题或投稿请发送至: 邮箱/279061341@qq.com    QQ/279061341

    猜你喜欢
    • C#中的数组怎么使用
      今天小编给大家分享一下C#中的数组怎么使用的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。如果需要使用同一类型的多个对象,可以...
      99+
      2023-06-30
    • C++中的数组怎么使用
      这篇文章主要介绍“C++中的数组怎么使用”的相关知识,小编通过实际案例向大家展示操作过程,操作方法简单快捷,实用性强,希望这篇“C++中的数组怎么使用”文章能帮助大家解决问题。1 概述所谓数组,就是一个集合,里面存放了相同类型的数据元素。特...
      99+
      2023-06-29
    • C++中怎么使用数组参数
      这期内容当中小编将会给大家带来有关C++中怎么使用数组参数,文章内容丰富且以专业的角度为大家分析和叙述,阅读完这篇文章希望大家可以有所收获。对于经验丰富的编程人员来说,C++编程语言应该是他们经常使用于程序开发的一种实用性语言。那么,在C+...
      99+
      2023-06-17
    • 怎么进行C语言中数组的使用
      怎么进行C语言中数组的使用,相信很多没有经验的人对此束手无策,为此本文总结了问题出现的原因和解决方法,通过这篇文章希望你能解决这个问题。1 数组的基本概念数组:类型相同的数据元素的集合,是C语言中的一种构造数据类型。这些元素会顺序地存储在内...
      99+
      2023-06-22
    • C语言中的柔性数组怎么使用
      这篇文章主要讲解了“C语言中的柔性数组怎么使用”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“C语言中的柔性数组怎么使用”吧!1.什么是柔性数组柔性数组就是大小可以变化的数组。注意跟C99中的...
      99+
      2023-07-06
    • C语言中的数组怎么创建和使用
      本文小编为大家详细介绍“C语言中的数组怎么创建和使用”,内容详细,步骤清晰,细节处理妥当,希望这篇“C语言中的数组怎么创建和使用”文章能帮助大家解决疑惑,下面跟着小编的思路慢慢深入,一起来学习新知识吧。一维数组的创建和初始化1.数组的创建数...
      99+
      2023-06-30
    • C#泛型数组怎么使用
      本篇内容介绍了“C#泛型数组怎么使用”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!C# 泛型和数组在 C# 2.0 中,下限为零的一维数组自...
      99+
      2023-06-17
    • C#动态数组怎么使用
      这篇文章主要讲解了“C#动态数组怎么使用”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“C#动态数组怎么使用”吧!下面是用法示例,例子很简单,就不用加注释了。public stati...
      99+
      2023-06-17
    • c++中的动态数组怎么用
      这篇文章给大家分享的是有关c++中的动态数组怎么用的内容。小编觉得挺实用的,因此分享给大家做个参考,一起跟随小编过来看看吧。C++的new操作符是该语言一个非常好的语法特性,然而实际使用中却发现new操作符有不少限制,为突出的一点便是用ne...
      99+
      2023-06-03
    • c语言数组指针怎么使用
      在C语言中,数组和指针是密切相关的。数组名本身就是指向数组第一个元素的指针。因此,可以使用指针来操作数组。下面是一些常见的数组指针用...
      99+
      2023-10-18
      c语言
    • C语言柔性数组怎么使用
      今天小编给大家分享一下C语言柔性数组怎么使用的相关知识点,内容详细,逻辑清晰,相信大部分人都还太了解这方面的知识,所以分享这篇文章给大家参考一下,希望大家阅读完这篇文章后有所收获,下面我们一起来了解一下吧。一、前言仔细观察下面的代码,有没有...
      99+
      2023-07-05
    • Java中数组怎么使用
      这篇文章主要为大家展示了“Java中数组怎么使用”,内容简而易懂,条理清晰,希望能够帮助大家解决疑惑,下面让小编带领大家一起研究并学习一下“Java中数组怎么使用”这篇文章吧。数组说明 数组是Java语言中的特殊类型。它们存放能通过索引来引...
      99+
      2023-06-03
    • C语言中数组的使用详解
      目录1 数组的基本概念2 数组定义语法3 一维数组的初始化3.1 全部初始化3.2 部分元素赋初值3.3 省略长度赋初值4 一维数组的使用示例4.1 求最大值、最小值、平均值4.2 ...
      99+
      2024-04-02
    • Visual C#数组怎么用
      这篇文章主要介绍了Visual C#数组怎么用,具有一定借鉴价值,感兴趣的朋友可以参考下,希望大家阅读完这篇文章之后大有收获,下面让小编带着大家一起了解一下。存储相关数据项组是大多数软件应用程序的一项基本要求;这可以通过使用Visual C...
      99+
      2023-06-17
    • C语言中0数组\柔性数组的使用详解
      前言: 上次看到一篇面试分享,里面有个朋友说,面试官问了char[0] 相关问题,但是自己没有遇到过,就绕过了这个问题。 我自己在这篇文章下面做了一些回复。 现在我想结合我自己...
      99+
      2024-04-02
    • 在Visual中C#是怎么使用COM组件的
      这篇文章主要讲解了“在Visual中C#是怎么使用COM组件的”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“在Visual中C#是怎么使用COM组件的”吧!Visual C#是微软推出的新一...
      99+
      2023-06-17
    • C++中的Lambda函数怎么使用
      这篇文章主要讲解了“C++中的Lambda函数怎么使用”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“C++中的Lambda函数怎么使用”吧!一 函数语法我们平时调用函数的时候,都是需要被调用...
      99+
      2023-06-22
    • c++中的seekg()函数怎么使用
      在C++中,`seekg()`函数用于将文件的读取位置移动到指定的位置。`seekg()`函数有两个参数:1. `offset`:表...
      99+
      2023-08-19
      c++ seekg()
    • C#中的DateTime函数怎么使用
      本篇内容主要讲解“C#中的DateTime函数怎么使用”,感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷,实用性强。下面就让小编来带大家学习“C#中的DateTime函数怎么使用”吧!一、初始化:DateTime dt&nbs...
      99+
      2023-07-02
    • C++中的sort()函数怎么使用
      这篇文章主要介绍“C++中的sort()函数怎么使用”的相关知识,小编通过实际案例向大家展示操作过程,操作方法简单快捷,实用性强,希望这篇“C++中的sort()函数怎么使用”文章能帮助大家解决问题。sort(v.begin(),v.end...
      99+
      2023-07-05
    软考高级职称资格查询
    编程网,编程工程师的家园,是目前国内优秀的开源技术社区之一,形成了由开源软件库、代码分享、资讯、协作翻译、讨论区和博客等几大频道内容,为IT开发者提供了一个发现、使用、并交流开源技术的平台。
    • 官方手机版

    • 微信公众号

    • 商务合作