精华内容
下载资源
问答
  • 2020-11-08 14:49:10

    #include<stdio.h>;

    int main()
    {
    int i;
    int j;

           //可根据菱形的不同进行相应的更改
           char a[][5] = { {' ',' ','*'},{' ','*','*','*'},{'*','*','*','*','*'},{ ' ','*','*','*' },{ ' ',' ','*' } };
    
           //每一行的输出
           for (i = 0; i < 5; i++)
                {
                     for (j = 0; j < 5; j++)
            {
                          printf("%c", a[i][j]);
             }
    
                 //换行
                 printf("\n");
     }
    
          //返回
          return  0;
    

    }

    更多相关内容
  • C语言动态数组从键盘读入n个整数,使用动态数组存储所读入的整数,并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其整数部分。样例输入:53 4 0 0 2样例输出:9 1样例输入:73...

    C语言动态数组

    从键盘读入n个整数,使用动态数组存储所读入的整数,并计算它们的和与平均值分别输出。要求尽可能使用函数实现程序代码。平均值为小数的只保留其整数部分。

    样例输入:

    5

    3 4 0 0 2

    样例输出:

    9  1

    样例输入:

    7

    3 2 7 5 2 9 1

    样例输出:

    29  4

    代码如下:

    #include

    int addAll(int a[],int N);

    int aveFun(int sum,int n);

    int main(){

    int N;

    int sum=0,ave=0;

    scanf("%d",&N);

    int a[N];

    for(int i=0;i

    scanf("%d",&a[i]);

    }

    sum = addAll(a,N);

    ave = aveFun(sum,N);

    printf("%d %d",sum,ave);

    }

    int addAll(int a[],int N){

    int sum=0;

    for(int i=0;i

    sum += a[i];

    }

    return sum;

    }

    int aveFun(int sum,int N){

    return sum/N;

    }

    感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

    展开全文
  • vector是指能够存放任意类型的动态数组,而C语言中并没有面向对象的C++那样内置vector类,所以我们接下来就来看一下使用C语言实现vector动态数组的实例,需要的朋友可以参考下
  • C语言基础:二维动态数组输入输出

    千次阅读 2018-03-15 22:05:09
    #include&lt;stdio.h&gt;#include&lt;stdlib.h&gt;...//输入二维数组的行数 scanf("%d",&amp;row); a=(int **)malloc(sizeof(int)*row); printf("Please e...
    #include<stdio.h>
    #include<stdlib.h>
    int main()
    {
    int **a,row,col,i,j;
    printf("Please enter array row:");//输入二维数组的行数
    scanf("%d",&row);
    a=(int **)malloc(sizeof(int)*row);

    printf("Please enter array rows:");//输入二维数组的列数
    scanf("%d",&col);

    for(i=0;i<row;i++)
    {
    a[i]=(int *)malloc(sizeof(int)*col);
    }

    printf("input:\n");  
        for(i=0;i<row;i++)
    {  
             for(j=0;j<col;j++)
             {
              scanf("%d",&a[i][j]);
             }
        }  
      
        printf("output:\n");  
        for(i=0;i<row;i++)
    {  
             for(j=0;j<col;j++)
             {
              printf("%d ",a[i][j]);
             }
             printf("\n");
        }  
      
        return 0; 
    }
    展开全文
  • cpp代码-(一维数组/动态存储)按指定长度生成动态数组,随机赋值给元素,而后输出原数组与逆置后数组
  • C++ 动态数组

    千次阅读 2022-01-21 14:08:03
    C++语言和标准库提供了两种一次分配一个对象数组的方法。C++语言定义了另一种new表达式语法,可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类,允许我们将分配和初始化分离。使用allocator通常会...

    C++语言和标准库提供了两种一次分配一个对象数组的方法。C++语言定义了另一种new表达式语法,可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类,允许我们将分配和初始化分离。使用allocator通常会提供更好的性能和更灵活的内存管理能力。

    new和数组

    为了让new分配一个对象数组,我们要在类型名之后跟一对方括号,在其中指明要分配的对象的数目。在下例中,new分配要求数量的对象并(假定分配成功后)返回指向第一个对象的指针:

    int get_size_new()
    {
        return 42;
    }
    void new_array()
    {
        int *p_array = new int[get_size_new()]();
        for (int i = 0; i < get_size_new(); i++)
        {
            cout << *(p_array + i) << " ";
        }
    
        delete[] p_array;
        cout << endl;
    }
    

    在main函数中调用new_array会输出42个0,因为new 分配的数组初始值都为0。
    为了释放动态数组,我们使用一种特殊形式的delete——在指针前加上一个空方括号对.
    方括号中的大小必须是整型,但不必是常量。也可以用一个表示数组类型的类型别名,来分配一个数组,这样,new表达式中就不需要方括号了:

    void new_array()
    {
        //定义数组类型
        typedef int array_type[10];
        //动态开辟数组空间
        int *p_array = new (array_type);
        delete[] p_array;
    }
    

    虽然我们通常称new T[]分配的内存为“动态数组”,但这种叫法某种程度上有些误导。
    当用new分配一个数组时,我们并未得到一个数组类型的对象,而是得到一个数组元素类型的指针。
    即使我们使用类型别名定义了一个数组类型,new也不会分配一个数组类型的对象。new返回的是一个元素类型的指针。
    由于分配的内存并不是一个数组类型,因此不能对动态数组调用begin或end。
    要记住我们所说的动态数组并不是数组类型,这是很重要的。
    可以通过{}初始化动态数组

    void new_array()
    {
        //通过{}初始化动态数组
        int *p_array = new int[10]{1, 2, 3, 4};
        //释放动态数组
        delete[] p_array;
    }
    

    如果{}初始化列表小于数组长度,则默认补充空值,int补充0,string补充空字符串。
    动态分配一个大小为0的数组是合法的

    void new_array()
    {
        int n = 0;
        //开辟一个大小为0的数组
        int *p_array = new int[n];
        for (int *p = p_array; p != n + p_array; p++)
        {
            cout << *p << " ";
        }
    
        delete[] p_array;
    }
    

    当n为0时,开辟了一个长度为0的动态数组,因为循环条件p != n+p_array,所以不会进入循环。
    当我们用new分配一个大小为0的数组时,new返回一个合法的非空指针。此指针保证与new返回的其他任何指针都不相同。
    对于零长度的数组来说,此指针就像尾后指针一样,我们可以像使用尾后迭代器一样使用这个指针。
    可以用此指针进行比较操作,就像上面循环代码中那样。可以向此指针加上(或从此指针减去)0,也可以从此指针减去自身从而得到0。但此指针不能解引用——毕竟它不指向任何元素。

    智能指针和动态数组

    标准库提供了一个可以管理new分配的数组的unique_ptr版本。为了用一个unique_ptr管理动态数组,我们必须在对象类型后面跟一对空方括号:

    void unique_array()
    {
        //开辟一个20个整形的动态数组,用unique_ptr管理它。
        auto unarray = unique_ptr<int[]>(new int[20]);
        //释放这个动态数组
        unarray.release();
    }
    

    类型说明符中的方括号<int[]>指出up指向一个int数组而不是一个int。由于unarray指向一个数组,当unarray销毁它管理的指针时,会自动使用delete[]。
    当一个unique_ptr指向一个数组时,我们可以使用下标运算符来访问数组中的元素:

    void unique_array()
    {
        //开辟一个20个整形的动态数组,用unique_ptr管理它。
        auto unarray = unique_ptr<int[]>(new int[20]);
    
        //可以通过下标访问数组元素
        for (size_t i = 0; i < 10; i++)
        {
            unarray[i] = 1024;
        }
    
        //释放这个动态数组
        unarray.release();
    }
    

    shared_ptr也可以管理动态数组,这一点在C++ primer 第5版里没有提及,但是我自己测试好用

    void shared_array()
    {
        // 开辟一个5个整形的动态数组,用shared_ptr管理它
        auto sharray = shared_ptr<int[]>(new int[5]{1, 2, 3, 4, 5});
        for (int i = 0; i < 5; i++)
        {
            cout << sharray[i] << " ";
        }
        sharray.reset();
        cout << endl;
    }
    

    C++ primer 第5版推荐的用法如下

    void use_shared_array()
    {
        shared_ptr<int> sharray = shared_ptr<int>(new int[5], [](int *p)
                                                  { delete[] p; });
        sharray.reset();
    }
    

    上例中,shared_ptr管理一个动态数组并提供了删除器。

    allocator类

    当分配一大块内存时,我们通常计划在这块内存上按需构造对象。在此情况下,我们希望将内存分配和对象构造分离。这意味着我们可以分配大块内存,但只在真正需要时才真正执行对象创建操作(同时付出一定开销)。

    类似vector,allocator是一个模板。为了定义一个allocator对象,我们必须指明这个allocator可以分配的对象类型。
    当一个allocator对象分配内存时,它会根据给定的对象类型来确定恰当的内存大小和对齐位置:

    void use_allocator()
    {
        allocator<string> alloc;
        // allocator分配5个string类型对象的空间
        // 这些空间未构造
        auto const p = alloc.allocate(5);
        //销毁开辟的空间
        alloc.deallocate(p, 5);
    }
    

    上述代码用allocator构造alloc对象,说明开辟的空间是为string对象准备的,然后调用allocate开辟空间,但是这些空间不能直接使用,需要调用构造函数才能使用,我们用allocator类的construct来构造对象。

    void use_allocator()
    {
        allocator<string> alloc;
        // allocator分配5个string类型对象的空间
        // 这些空间未构造
        auto p = alloc.allocate(5);
        auto q = p;
        string str = "c";
        for (; q != p + 5; q++)
        {
            //构造字符串,每次字符串增加c字符
            alloc.construct(q, str);
            str += "c";
        }
        // //打印构造的字符串列表
        for (q = p; q != p + 5; q++)
        {
            cout << *q << endl;
        }
    
        //销毁开辟的空间
        alloc.deallocate(p, 5);
    }
    

    循环中通过construct为每个q指向的空间构造string对象,对象的内容就是str的内容,str会随着循环每次增加c,所以上面的代码输出如下

    c
    cc
    ccc
    cccc
    ccccc
    

    另外stl也提供了一些拷贝和填充内存的算法

    void use_allocator()
    {
        vector<int> ivec = {1, 2, 3, 4, 5};
        allocator<int> alloc;
        //开辟2倍ivec大小的空间
        auto p = alloc.allocate(ivec.size() * 2);
        //将ivec的内容copy至alloc开辟的空间里
        //返回q指向剩余未构造的内存空间的起始地址
        auto q = uninitialized_copy(ivec.begin(), ivec.end(), p);
        //将剩余元素初始化为42
        uninitialized_fill_n(q, ivec.size(), 42);
    }
    

    通过uninitialized_copy将ivec元素拷贝到p指向的空间,同样完成了构造。
    uninitialized_fill_n将剩余ivec大小未构造的空间全部初始化为42。

    总结

    本文介绍了动态数组开辟的方法,利用new关键字可以开辟动态数组,利用delete[]可以回收数组。
    也实现了通过shared_ptr和unique_ptr等智能指针管理动态数组的方案。
    最后通过列举allocator的一些方法,展示了如何实现开辟空间和构造对象分离的方式动态构造对象。
    源码连接
    https://gitee.com/secondtonone1/cpplearn
    想系统学习更多C++知识,可点击下方链接。
    C++基础

    展开全文
  • VB中,动态数组中输入数据

    千次阅读 2019-06-10 23:14:06
    Private Sub Command1_Click() Text1.Text = “” Dim s As Long, i As Long Dim a() Do ReDim Preserve a(s) a(s) = InputBox(“请输入字符串,输入空串时结束”, “输入”) s = s + 1 Loop Until a(s - 1) = “” ...
  • Java 动态数组

    2021-11-17 10:49:42
    为了保证程序中使用了二维数组,需在打印完乘法口诀表后使用Arrays.deepToString打印二维数组中的内容。 提醒:格式化输出可使用String.format或者System.out.printf。 输出格式说明 每行末尾无空格。 每一项...
  • //C语言的二维动态数组 #include<cstdio> #include<string.h> #include<malloc.h> int main(){ char ** strs=(char **)malloc(sizeof(char*)*3); int (*p)[20]; for(int i=0;i<3;i++){.....
  • 动态数组与静态数组之间的转化

    千次阅读 2015-08-17 10:54:34
    1 将动态数组转化为静态数组 [code="java"] public class Test { public static void main(String[] args) { List list=new ArrayList(); list.add("王利虎"); list.add("...
  • Java实现动态数组

    千次阅读 2021-03-05 14:41:44
    动态数组的Java实现思路:底层用一个固定长度的数组element来保存数据,每插入一个元素之前先判断一下size+1是否大于底层数组element的长度,如果大于,那么将生成一个大于原来数组长度两倍的数组,然后将原有数据...
  • C语言中如何定义动态二维数组输出

    万次阅读 多人点赞 2017-04-30 17:31:45
    可以按照下面步骤进行定义二维数组输出: 1 定义二维指针。 2 确定数组维数,即行数和列数。 3 申请行数个一维指针大小空间,并赋值给二维指针。 4 对于每个一维指,申请列数个元素的空间,并赋值给...
  • import java.util.Scanner; public class ArrTest { public static void main(String[] args) { Scanner sc = new Scanner(System.in);... //输入数值确定动态数组长度 double sum = 0; for (int i
  • C语言动态数组数据类型(动态数组库)动态数组库功能设计源文件、具体实现测试程序和运行结果 动态数组库功能设计 静态数组一经创建大小不能改变。动态数组更灵活,可以在程序运行时根据需要指定数组大小。 这个...
  • 1.定宽数组 声明: int lo [0:15]; int lo [16]; //16个整数[0]...[15] int arr[0:7] [0:3]; // 等效与 int arr[8] [4]; 8行4列的数组 arr[8] [4]=1;// 设置数组的最后一个元素为1 知识1 – for 和 foreach 的...
  • c++动态数组的使用 new

    2022-02-17 18:20:21
    在c++中,有的时候会遇到变长的数组(不管是一维的还是二维的),这个时候就需要用到动态数组了,并且要用new和delete两个操作符,这俩操作符一般成对使用。 一维的动态数组 #include<iostream> using ...
  • SV数据类型之定宽数组与动态数组
  • C语言动态数组的逆序输出 #include "stdio.h" #include "stdlib.h" void nxsz(int *array,int n) { for(int i=n;i>=0;i--) printf("%10d",array[i]); } int main() { int N; printf("请输入数组长度%d\n"); ...
  • VBA动态数组简单应用

    千次阅读 2021-01-18 12:35:36
    当一行数据满足筛选要求时,将该行数据写入到新的数组中,逐维增加,最后再将这个新的数组输出到表格. 动态数组和一静态数组定义不同 静态数组定义: dim arr 动态数组定义: dim arr() 重新定义动态数组: ...
  • Java动态数组是一种可以任意伸缩数组长度的对象,在Java中比较常用的是ArrayList,ArrayList是javaAPI中自带的java.util.ArrayList。下面介绍一下ArrayList作为Java动态数组的用法。1.语法:add()是添加一个新的元素...
  • 通常,我们会用高级程序语言中的数组来描述线性表的顺序存储结构,而这种顺序表的特点时逻辑顺序与物理顺序相同,即数组中元素的内存地址是连续的。 那么很显然,这样的数组(静态数组)是在空间被占满后再往里添加...
  • C++中输入动态数组

    千次阅读 2021-03-17 16:29:53
    #include<stdio.h> #include<iostream> #include<vector> using namespace std; int main(){ int a; vector<int> v; while(cin>>a) { v.push_back(a); if(cin.getchar()=='\...&
  • 牛客网基础C++编程-创建动态数组
  • 动态数组 动态数组的声明: 动态数组在使用前要必须用new[]对其分配空间,然后才可以对其进行复制等车操作: 输出结果为: 上述结果显示对动态数组new[]过后,其内部已经为其分配了空间,并存放了默认值。 队列 ...
  • Java中用二维数组输出杨辉三角

    千次阅读 2020-08-12 20:45:25
    创建数组的两种方式: ①数据类型[ ][ ] 数组名 = new 数据类型[行数][列数],如 int[ ][ ] a = new int[2][3];这样就创立了2行三列的二...接下来就来用二维数组输出杨辉三角: import java.io.FileInputStream; impo
  • 围绕“在动态数组中逆置元素”这一任务,分析puts()函数、Sleep()函数、数组元素逆置的方法、二级指针作函数参数和动态空间深层理解这五个知识点。
  • 随后,通过for循环删除动态数组中值为 erase_num 的元素,并输出最后结果。 #include <vector> #include <iostream> using namespace std; int main() { // 初始化 int erase_num = 3; int int_...
  • 本文主要介绍了C语言中“stdlib.h”库下的核心函数“malloc()”在一维动态数组和二维动态数组的使用方式。代码量较多,文字叙述较少,但绝对通俗易懂。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 378,951
精华内容 151,580
关键字:

动态数组输出