天道酬勤,学无止境

How do I create a dynamically sized array, or re-size an array in c#?

I need to know how to dynamically re-size an array in C#. In the method that I have written below, I need to be able to return an array that only contains the numbers that were input by the user up to 8 numbers. So if the user decides they only want to enter 3 numbers, the array should only contain 3 numbers, not 8.

Now I know that an array needs to include a size when instantiated. So how do I get around this without using a list? Is there a way to re-size the array after the loop is done?

Thanks in advance.

        static int[] fillArray()
    {
        int[] myArray;
        myArray = new int[8];
        int count = 0;
        do
        {
            Console.Write("Please enter a number to add to the array or \"x\" to stop: ");
            string consoleInput = Console.ReadLine();
            if (consoleInput == "x")
            {
                Array.Resize(ref myArray, count);
                return myArray;
            }
            else
            {
                myArray[count] = Convert.ToInt32(consoleInput);
                ++count;
            }

        } while (count < 8);

        Array.Resize(ref myArray, count);
        return myArray;

    }
标签

评论

You could use a List<int> during your method logic and then return myIntList.ToArray();

Typically for this type of application you'll want to use a List. And if you really need an array you can use the ToArray method but reconsider if an array is really what you want. Usually a List is used for a dynamically sized collection instead of an array.

You could always modify your code as follows:

static int[] fillArray()
{
    List<int> list = new List<int>();

    do
    {
        Console.Write("Please enter a number to add to the array or \"x\" to stop: ");
        string consoleInput = Console.ReadLine();

        if (consoleInput == "x")
        {
            return list.ToArray();
        }
        else
        {
            list.Add(Convert.ToInt32(consoleInput));
        }

    } while (count < 8);

    return list.ToArray();
}

But as I mentioned before, really reconsider changing your method to return a List and use the List in your calling code.

Well you could implement your own method accepting the array and new size as parameters that would create new array, deep-copy the elements and then assign to your array. Array.Resize() does the same, you can watch it with disassembler

受限制的 HTML

  • 允许的HTML标签:<a href hreflang> <em> <strong> <cite> <blockquote cite> <code> <ul type> <ol start type> <li> <dl> <dt> <dd> <h2 id> <h3 id> <h4 id> <h5 id> <h6 id>
  • 自动断行和分段。
  • 网页和电子邮件地址自动转换为链接。

相关推荐
  • std :: dynarray与std :: vector(std::dynarray vs std::vector)
    问题 C ++ 14提出了std :: dynarray: std :: dynarray是一个序列容器,该容器封装大小固定在构造上的数组,并且在对象的整个生命周期中都不会改变。 std::dynarray必须在运行时与std::vector一样分配。 那么std::dynarray的好处和用法是std::dynarray而我们可以使用更动态(也可以调整大小)的std::vector ? 回答1 那么,当我们可以使用更具动态性( std::dynarray大小)的std::vector时, std::dynarray的好处和用法是什么? dynarray比vector更小,更简单,因为它不需要管理单独的大小和容量值,并且不需要存储分配器。 但是,主要的性能好处是来自以下事实:鼓励实现在可能的情况下在堆栈上分配dynarray ,避免任何堆分配。 例如 std::dynarray<int> d(5); // can use stack memory for elements auto p = new std::dynarray<int>(6); // must use heap memory for elements 这种优化需要编译器的配合,无法将其实现为纯库类型,并且还没有实现必要的编译器魔术,而且没人知道这样做有多么容易。 由于缺乏实施经验,在上周于芝加哥举行的C +
  • 当我必须指定内存大小时,malloc 数组和常规数组有什么区别?(What is the difference between malloc array and regular array when in both I have to specify memory size?)
    问题 例如,当我必须指定内存大小时, malloc() -ed 数组和常规数组有什么区别 char* arr = malloc(50 * sizeof(char)) 对比 int arr [50] 回答1 嗯,有太多的不同。 首先,了解数组不是指针,反之亦然。 也就是说,从可用性的角度来看,三个主要区别(我觉得你很感兴趣) 数组的范围仅限于其封闭块,但除非手动释放,否则动态分配的内存会一直存在。 所以,数组函数的局部不能retrun ED但一个指针,经由返回malloc() -ing,都可以。 对于非 VLA 情况,数组大小必须是编译时常量,但对于malloc()大小是在运行时指定的。 换句话说,对于数组,您需要在编译时知道大小,而对于malloc() -ing,完全有可能在运行时确定请求的大小。 数组不能重新调整大小。 定义后,它们将使用其大小所需的所有内存。 OTOH,一个malloc() -ed 指针,指向一定数量的内存,可以很好地根据需要realloc() -ed 到其他一些内存量。 回答2 主要区别在于动态分配的内存可以根据需要调整大小; 数组(静态、自动或可变长度)一旦被实例化就不能调整大小。 第二个区别与数组的生命周期有关。 在文件范围内或使用static关键字声明的数组的生命周期会在程序的整个生命周期内延长。
  • 将 CSV 文件转换为二维数组(Converting CSV File Into 2D Array)
    问题 我在一维数组中有一个我的想法的例子。 它只会输出列。 我的想法是使用二维数组来选择行和列。 这是我的代码: String fName = "c:\\csv\\myfile.csv"; String thisLine; int count=0; FileInputStream fis = new FileInputStream(fName); DataInputStream myInput = new DataInputStream(fis); int i=0; while ((thisLine = myInput.readLine()) != null) { String strar[] = thisLine.split(";"); out.println(strar[1]); // Here column 2 } 我的文件.csv Id;name E1;Tim A1;Tom 输出: 姓名蒂姆·汤姆 回答1 我只是将拆分结果( String[] )添加到List然后如果您真的想要它作为二维数组,那么在事后将其转换。 List<String[]> lines = new ArrayList<String[]>(); while ((thisLine = myInput.readLine()) != null) { lines.add(thisLine.split(";"));
  • c++ 数组,如何在同一个数组中添加新的一行值?(c++ arrays, how to add a new row of values in the same array?)
    问题 如何根据用户输入或 cin 在数组中创建新的一行值? 假设数组中已有一行值,您需要添加第二行值但未添加到第一行,以及如何将大括号和逗号放入,用户是否放入或有什么东西这将自动将括号和逗号放入 int test [] = { 1, 21, 771, 410, 120711 }, { 1, 2, 3, 4, 5 }; 回答1 如果没有非常糟糕和肮脏的技巧,这是不可能的。 更好地使用列表或向量(最接近数组)。 另一种可能性是使用指针并扩展它创建一个临时内存,复制旧数据然后添加新数据。 回答2 无法在保留其内容的同时更改数组的大小。 改变数组大小的唯一方法是使用new运算符为指针分配动态内存,但这会破坏数组之前保存的所有数据。 如果你想要一个可重新调整大小的数组,你可能应该使用std::vector. 回答3 如果您热衷于使用 c++11,您可以使用 std::vector 保留初始化列表,如下所示: #include <vector> int main() { // initialise std::vector<std::vector<int>> test = { { 1, 21, 771, 410, 120711 }, { 1, 2, 3, 4, 5 } }; // add new data from user test.push_back({9, 8, 7, 6, 5, 4, 3
  • Whats the difference? Pointer to an array vs regular array
    I'm familiar with Java and trying to teach myself C/C++. I'm stealing some curriculum from a class that is hosting their materials here. I unfortunately can't ask the teacher since I'm not in the class. My concern is with the section under "dynamically declared arrays": If you want to be able to alter the size of your array at run time, then declare dynamic arrays. These are done with pointers and the new operator. For the basics on pointers, read the pointers section. Allocate memory using new, and then you access the array in the same way you would a static array. For example, int* arrayPtr
  • 什么时候应该使用动态内存分配函数而不是直接变量声明?(When should one use dynamic memory allocation function versus direct variable declaration?)
    问题 下面是一个直接变量声明的例子。 double multiplyByTwo (double input) { double twice = input * 2.0; return twice; } 下面是一个动态内存分配的例子。 double *multiplyByTwo (double *input) { double *twice = malloc(sizeof(double)); *twice = *input * 2.0; return twice; } 如果我有选择,我会一直使用直接变量声明,因为代码看起来更易读。 什么时候动态内存分配更合适? 回答1 什么时候动态内存分配更合适? 当编译时不知道分配大小时,我们需要使用动态内存分配。 除了上面的情况,还有一些其他的场景,比如 如果我们想要一个在运行时可重新调整大小的数据结构,我们需要进行动态内存分配。 动态分配的内存的生命周期保持有效,除非它是free() d。 有时,当从函数调用返回某个变量的地址时,它会派上用场,否则,如果使用auto变量,就会超出范围。 通常堆栈大小会受到适度限制。 如果要创建和使用庞大的数组,最好使用动态内存分配。 这将从堆中分配内存。 回答2 使用 malloc 进行动态内存分配将内存放在堆上,因此在离开函数时不会被销毁。 稍后您需要手动释放内存。 直接声明落在堆栈上并在离开函数时被删除。
  • 向量数组还是数组向量?(array of vectors or vector of arrays?)
    问题 我是 C++ STL 的新手,我无法理解图形表示。 vector<int> adj[N]; 那么这是创建一个向量类型的数组还是创建一个数组向量? BFS 代码似乎遍历了 adj[i] 的每个实例中存在的值列表,因此它看起来像一个向量数组。 创建向量的语法是: vector<int> F; 这将有效地创建一个单维向量 F。 之间有什么区别 vector< vector<int> > N; 和 vector<int> F[N] 回答1 那么这( vector<int> adj[N]; )是创建了一个向量类型的数组还是创建了一个数组向量? 它创建向量数组 之间有什么区别vector< vector<int> > N; 和vector<int> F[N] 在第一种情况下,您正在创建动态数组的动态数组(向量的向量)。 每个向量的大小可以在运行时更改,所有对象都将在堆上分配。 在第二种情况下,您正在创建一个固定大小的向量数组。 您必须在编译时定义N ,并且所有向量都将放置在堆栈† 上,但是,每个向量都将在堆上分配元素。 在编译时大小的情况下,我总是更喜欢向量案例(或矩阵,如果您可以使用第三方库)或std::array的std::array s。 我是 C++ STL 的新手,我无法理解图形表示。 您也可以将图形表示为std::unordered_map<vertex_type,std
  • 为什么不能调整数组大小?(Why can't arrays be resized?)
    问题 为什么不能动态调整大小(原始数组或其他数组)的原因是什么? 我知道您可以使用ArrayList ,但是其背后的实现仍然是一个初始大小的数组(我认为默认情况下为50),并且当它超过50时,将创建一个包含这些元素的新数组。 因此,我试图了解使其无法调整大小的数组的系统规范。 回答1 这是一个有效的问题,答案与计算机的实际工作方式有关。 创建数组时,例如使用int[] array = new int[5] ,计算机将在内存中保留五个连续的空间,以供该数组中包含的数据使用。 但是,此后的内存空间可立即用于存储其他信息。 如果以后要调整数组的大小,则必须将其他信息移到其他位置才能使数组变大。 这是我们不想处理的许多杂乱无章的事情,因此计算机架构师不允许使用数组大小​​调整来简化事情。 回答2 数组实际上是一个连续的内存块。 根据初始化的内容,它可以相对较小,也可以相对较大。 比方说,例如,我有一个由十个元素组成的数组。 int[] arr = new int[10]; JVM的基础实现现在必须向OS请求40个连续的字节才能分配给程序。 操作系统必须执行,现在您有40个字节,可以使用熟悉的名称arr来使用。 请注意,此数组可能在其两侧共享空间-数组附近还有其他参考或信息位,它不能只是移至自身的第11个位置并“声明”它。 假设我们认为10太短。 我们需要将其放大-扩大十倍。 int
  • 在重新调整大小时操纵jquery菜单以进行响应式布局(Manipulate jquery menu on re-size for responsive layout)
    问题 有一个带有菜单项的简单菜单。 UL LI。 LI的宽度和数量是动态的。 鼠标悬停/单击时会出现下拉菜单“更多”,它会显示剩余的LI,这将不适合可用空间。 当用户从右向左调整窗口大小时,我尝试使用jquery,它将隐藏最后一个可见的菜单项。 进行此逆转并在“更多”链接中添加LI的可能方法是什么。 尝试了一些选择,因为当我们调整大小时宽度较小,然后列表项移至下方并增加UL的高度,因此使用此方法,我可以隐藏最后可见的内容。 代码 http://jsbin.com/flexmenu/2/edit 步骤1 第2步 第三步 当用户调整大小(增加宽度)时,这些步骤将相反 标记 <div class="twelve columns filter-wrapper"> <ul class="nav-bar-filter" id="nav-bar-filter"> <li><a href="#">All</a></li> <li><a href="#">Small</a></li> <li><a href="#">Medium</a></li> <li><a href="#">Extra large</a></li> <li><a href="#">Text</a></li> <li><a href="#">Small-1</a></li> <li><a href="#">Medium-1</a>
  • 为什么我们需要StringBuilder中的容量(Why do we need capacity in StringBuilder)
    问题 众所周知,StringBuilder中有一个名为capacity的属性,该属性始终大于StringBuilder对象的长度。 但是,容量是用来做什么的? 如果长度大于容量,它将被扩展。 如果这样做,有人可以举个例子吗? 回答1 您可以使用初始容量来节省在附加StringBuilder时调整其大小的需求,这会花费时间。 如果预先知道将多少个字符附加到StringBuilder并在创建StringBuilder时指定该大小,则在使用它时就不必重新调整大小。 另一方面,如果您没有提供初始容量或设置的初始容量太小,则每次达到该容量时,都必须增加StringBuilder的存储量,这涉及复制存储在原始存储区中的数据。存储到更大的存储。 回答2 字符串生成器必须将正在生成的字符串存储在某个位置。 它是通过字符数组来完成的。 容量是此阵列的长度。 一旦数组溢出,就会分配一个新的(更长)数组,并将内容传输到该数组。 这使容量增加。 如果您不关心性能,则只需忽略容量。 一旦您要构造巨大的字符串并预先知道它们的大小,容量可能会变得很有趣。 然后,您可以请求一个字符串生成器,其容量应等于预期的大小(如果不确定大小,则可以稍大一些)。 构建内容大小为一百万的字符串时的示例: StringBuilder sb = new StringBuilder(1000000); for(int i = 0; i
  • OpenGL 渲染大量动态二维圆(OpenGL rendering large amounts of dynamic 2D circles)
    问题 我在这里看到了关于这个主题的类似帖子,但是,我的问题有点不同。 我有一个 2D 图,它将由不同位置的不同大小的圆圈组成。 目前,我的渲染方案使用一个显示列表来存储一个预先绘制的圆圈,用户可以使用 glScalef/glTranslatef 主动重新调整大小和翻译。 但是,因为我正在渲染数千个圆圈,所以调整大小和绘图变得非常缓慢。 每个圆可以有不同的半径和颜色,所以这些事情必须在循环中完成。 当用户更改圆圈的大小时,我可以尝试哪些方法来提高圆圈渲染的速度? 我已经像上面的链接所说的那样研究了 VBO,但是对于我的对象大小不断变化的这种类型的应用程序,我会获得多少性能提升是不明确的。 回答1 因为我正在渲染数千个圆圈,所以调整大小和绘图变得非常缓慢 仅使用顶点阵列,在具有 10,000 个圆圈的 Intel HD Graphics 3000 上每帧大约可以获得 60 毫秒: // g++ -O3 circles.cpp -o circles -lglut -lGL #include <GL/glut.h> #include <vector> #include <iostream> #include <cmath> using namespace std; // returns a GL_TRIANGLE_FAN-able buffer containing a unit
  • Combining 2D (2-dimensional) arrays
    I am using VBA in Excel to consume an XML file and dump specific information into individual tabs. I want to be able to combine 2-dimensional arrays. The arrays have a "known" number of columns but an "unknown" number of rows. Consider the following two arrays: array1: a b c d e f array2: 1 2 3 4 5 6 How do I combine these to arrays if I want the following result: array3: a b c d e f 1 2 3 4 5 6 And just out of curiosity, how would I code if instead I wanted to add to the right instead of the bottom, like this: array4: a b c 1 2 3 d e f 4 5 6 I can't seem to find the answer to this anywhere
  • c ++ unordered_map 碰撞处理,调整大小和重新散列(c++ unordered_map collision handling , resize and rehash)
    问题 我还没有阅读 C++ 标准,但这就是我觉得 c++ 的 unordered_map 应该工作的方式。 在堆中分配一个内存块。 对于每个放置请求,散列对象并将其映射到此内存中的空间在此过程中,通过链接或开放寻址处理冲突。 我很惊讶我找不到太多关于 unordered_map 如何处理内存的信息。 是否有 unordered_map 分配的特定初始内存大小。 如果假设我们分配了 50 个 int 内存并最终插入了 5000 个整数,会发生什么? 这将是很多碰撞,所以我相信应该有一种重新散列和重新调整大小的算法,以在达到一定级别的碰撞阈值后减少碰撞次数。 由于它们是作为成员函数显式提供给类的,因此我假设它们也在内部使用。 有这样的机制吗? 回答1 对于每个放置请求,散列对象并将其映射到此内存中的空间 不幸的是,这并不完全正确。 您指的是开放寻址或封闭散列数据结构,这不是unordered_map的指定方式。 每个unordered_map实现都将一个链表存储到桶数组中的外部节点。 这意味着插入一个项目将始终至少分配一次(新节点),如果不是两次(调整存储桶数组的大小,然后是新节点)。 不,这根本不是为大多数常见用途实现哈希映射的最有效方法。 不幸的是, unordered_map规范中的一个小“疏忽”几乎需要这种行为。 所需的行为是元素的迭代器在插入或删除其他元素时必须保持有效。
  • C / C ++有效位数组(C/C++ efficient bit array)
    问题 您能推荐一种高效/简洁的方法来操纵任意长度的位数组吗? 现在,我正在使用常规的int / char位掩码,但是当数组长度大于数据类型长度时,它们不是很干净。 std vector<bool>对我不可用。 回答1 如果仅在运行时知道长度,则使用boost :: dynamic_bitset。 如果长度在编译时是已知的,则为std :: bitset(尽管是任意的)。 回答2 由于您同时提到了C和C ++,因此我假定像boost::dynamic_bitset这样的面向C ++的解决方案可能不适用,而是讨论低级C的实现。 请注意,如果boost::dynamic_bitset类的东西对您boost::dynamic_bitset ,或者您可以找到一个预先存在的C库,那么使用它们比滚动自己的库更好。 警告:以下代码均未经过测试或编译,但应非常接近您的需求。 首先,假设您的比特集大小固定为N。然后,如下所示: typedef uint32_t word_t; enum { WORD_SIZE = sizeof(word_t) * 8 }; word_t data[N / 32 + 1]; inline int bindex(int b) { return b / WORD_SIZE; } inline int boffset(int b) { return b % WORD_SIZE
  • 不断改变数组大小[重复](continuously changing array size [duplicate])
    问题 这个问题在这里已经有了答案: 如何管理字符串数组中的连续变化值 [关闭] (1 个回答) 8 年前关闭。 我有一个字符串数组,但数组中的值不断变化。 除了删除项目和更改索引位置之外,还有其他管理数组的方法吗? public String[] deviceId=null; deviceId=new String[deviceCount]; 在我的情况下 deviceCount 会随着新设备的出现而变化。 所以我不断需要更改数组大小并添加或删除项目 回答1 使用 ArrayList 代替 String[] .. 您还可以轻松地将 ArrayList 转换为 String[] 作为最终输出 ArrayList<String> mStringList= new ArrayList<String>(); mStringList.add("ann"); mStringList.add("john"); String[] mStringArray = new String[mStringList.size()]; mStringArray = mStringList.toArray(mStringArray); 回答2 您可以使用列表。 它会根据您放入的对象数量改变大小。 List<String> list = new ArrayList<String>; public static
  • Linked list vs. dynamic array for implementing a stack
    I've started reviewing data structures and algorithms before my final year of school starts to make sure I'm on top of everything. One review problem said "Implement a stack using a linked list or dynamic array and explain why you made the best choice". To me, it seemed more intuitive to use a list with a tail pointer to implement a stack since it may need to be resized often. It seems like for a large amount of data, a list is the better choice since a dynamic array re-size is an expensive operation. Additionally, with a list, you don't need to allocate any more space than you actually need
  • C++ 等价于 Java 的 System.arraycopy(C++ equivalent to Java's System.arraycopy)
    问题 我正在尝试移植我的一些 Java 代码,这些代码大量使用 System.arraycopy 方法,并想知道 C++ 中是否有等价物。 基本上我想有 n 个字节数组并将它们组合成一个大数组。 每个初始数组都可以是可变长度,所以我不想通过计算结束数组长度然后一次填充整个数组一个位置的过程,因为这感觉很慢,我确定这一点操作进行了优化。 但是,我找不到这个优化是什么(虽然我可能使这比它应该的更复杂)。 这是一些伪(Java)代码来说明我想要做什么。 byte[] a = new byte[]{0x00, 0x01, 0x02}; byte[] b = new byte[][0x03, 0x04, 0x05]; byte[] ab = new byte[a.length+b.length]; System.arraycopy(ab, 0, a, 0, a.length); System.arraycopy(ab, a.length+1, b, 0, b.length); //Now, I would expect ab to look like {0x00, 0x01, 0x02, 0x03, 0x04, 0x05} 就像我说的,这在 C++ 中可能很简单,但我会多次这样做,并希望确保我尽可能高效地完成它。 回答1 给定 a_len 和 b_len(包含 a 和 b 的字节长度)
  • Dynamically re-sizable thread pool
    I have a following workflow in my application: there can be X requests from users (usually 5-10 simultaneously) who want to search for something in the system (each request is handled in a separate thread). Each search can be handled in parallel (which I am currently implementing). Threads/CPU usage isn't really the problem here as those tasks aren't CPU intensive. The database is the bottleneck. Currently I set up a separate DB connection pool only for the search mechanism - with max pool size set to 10. I know that's not much but I can't set it up higher. Now I am trying to figure out how to
  • 为什么列表在 Go 中很少使用?(Why are lists used infrequently in Go?)
    问题 我是 Go 的新手,对此非常兴奋。 但是,在我广泛使用的所有语言中:Delphi、C#、C++、Python - 列表非常重要,因为它们可以动态调整大小,而不是数组。 在 Golang 中,确实有一个list.List结构,但我很少看到关于它的文档——无论是在 Go By Example 还是我拥有的三本 Go 书籍——Summerfield、Chisnal 和 Balbaert——他们都花了很多时间在数组上和切片,然后跳到地图。 在源代码示例中,我也发现很少或根本没有使用list.List 。 似乎与 Python 不同的是,List 不支持Range ——IMO 的一大缺点。 我错过了什么吗? 切片当然很好,但它们仍然需要基于具有硬编码大小的数组。 这就是 List 的用武之地。有没有办法在没有硬编码数组大小的情况下在 Go 中创建数组 /slice? 为什么列表会被忽略? 回答1 当您考虑列表时,几乎总是 - 在 Go 中使用切片代替。 切片动态调整大小。 它们的底层是一个可以改变大小的连续内存片。 如果您阅读 SliceTricks wiki 页面,您就会发现它们非常灵活。 这是摘录:- 复制b = make([]T, len(a)) copy(b, a) // or b = append([]T(nil), a...) 切a = append(a[:i], a[j
  • Writing a large 2d array to Excel
    I'm looking to write a large 2d array to an Excel worksheet using C#. If the array is 500 x 500, the code that I would use to write this is as follows: var startCell = Worksheet.Cells[1, 1]; var endCell = Worksheet.Cells[500, 500]; var writeRange = (Excel.Range)Worksheet.Cells[startCell, endCell; writeRange.Value = myArray; I get an exception on this line: var endCell = Worksheet.Cells[500, 500]; As anybody who has used C# and Excel via COM can testify, the error message received is pretty much useless. I think that the issue is that the underlying data structure used for the worksheet is not