C++之数组

最新推荐文章于 2024-04-10 11:32:10 发布
最新推荐文章于 2024-04-10 11:32:10 发布
阅读量866 收藏 1
点赞数
分类专栏： C++基础 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35140742/article/details/118709490
版权

C++之数组

一维数组

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <iomanip>

using namespace std;

int main() {
    system("chcp 65001");
    double a[10];
    cout << "-------------初始数组的值-------------" << endl;
    for (int i = 0; i < 10; ++i) {
        cout << a[i] << endl;
    }
    for (int i = 0; i < 10; i++) {
        a[i] = i + 100;
    }
    cout << "-------------重新赋值数组的值-------------" << endl;
    cout << "Element" << setw(13) << "Value" << endl;
    for (int i = 0; i < 10; ++i) {
        cout << i << setw(7) << setw(17) << a[i] << endl;
    }
    return 0;
}

输出:
Active code page: 65001
-------------初始数组的值-------------
3.91881e-317
6.95223e-310
3.95253e-323
0
2.07618e-317
1.97626e-322
0
0
3.95253e-323
2.07493e-317
-------------重新赋值数组的值-------------
Element        Value
0              100
1              101
2              102
3              103
4              104
5              105
6              106
7              107
8              108
9              109

二维数组

初始化二维数组:int b[3][2] = {{1, 2},
                   {3, 4},
                   {5, 6}};

使用指针指向数组

#include <iostream>

using namespace std;

int main() {
    system("chcp 65001");
    int c[5] = {10, 20, 30, 40, 50};
    int *p;
    //输出数组名表示的是首元素的地址,指针p指向数组的第一个地址,这里的c相当于&c[0]
    p = c;
    cout << "----------使用指针表示数组的值----------" << endl;
    for (int i = 0; i < 5; ++i) {
        cout << "*(p[" << i << "]):"
             << *(p + i) << endl;
    }
    cout << "------使用数组名作为地址输出数组的值------" << endl;
    for (int i = 0; i < 5; ++i) {
        cout << "*(c[" << i << "]):"
             << *(c + i) << endl;
    }
    return 0;
}

输出:
Active code page: 65001
----------使用指针表示数组的值----------
*(p[0]):10
*(p[1]):20
*(p[2]):30
*(p[3]):40
*(p[4]):50
------使用数组名作为地址输出数组的值------
*(c[0]):10
*(c[1]):20
*(c[2]):30
*(c[3]):40
*(c[4]):50

特殊的char类型数组

1.C++ 中，将 char * 或 char[] 传递给 cout 进行输出，结果会是整个字符串，如果想要获得字符串的地址（第一个字符的内存地址），可使用以下方法：
强制转化为其他指针（非 char*）。可以是 void ，int ，float ， double * 等。 使用 &s[0] 不能输出 s[0]（首字符）的地址。因为 &s[0] 将返回 char，对于 char（char 指针），cout 会将其作为字符串来处理，向下查找字符并输出直到字符结束 *。
2.C++ 对 char 型数组做了特殊规定，直接输出首地址时，会输出数组内容。如果想得到地址，可采用 & 。

#include <iostream>

using namespace std;
const int MAX = 3;

int main() {
    system("chcp 65001");
    char var[MAX] = {'a', 'b', 'c'};
    char *p;
    p = var;
    cout << "输出char数组首地址时直接输出数组元素:" << p << endl;
    for (int i = 0; i < MAX; ++i) {
        cout << "One way Address of var[" << i << "]=";
        //cout << &var + i << endl;(error)
        //&var[i]是char*类型，直接输出的是字符，需要强转成其他类型得到地址
        cout << (double *) &var[i] << endl;
        cout << "Another way Address of var[" << i << "]=";
        //转成其他类型的数组输出地址
        cout << (int *) p << endl;
        //指针下移
        cout << "输出数组的值var[" << i << "]=" << *p << endl;
        p++;
    }

    return 0;
}

输出:
Active code page: 65001
输出char数组首地址时直接输出数组元素:abc
One way Address of var[0]=0x63fe11
Another way Address of var[0]=0x63fe11
输出数组的值var[0]=a
One way Address of var[1]=0x63fe12
Another way Address of var[1]=0x63fe12
输出数组的值var[1]=b
One way Address of var[2]=0x63fe13
Another way Address of var[2]=0x63fe13
输出数组的值var[2]=c

函数传递数组参数

#include <iostream>
#include <cstdlib>

using namespace std;

//不带索引的数组名（指针）
void my_func(int *pre);

//传带索引的数组参数
void my_func1(int pre[10]);

//传带空索引的数组参数
void my_func2(int pre[]);

void my_func(int *pre) {
    cout << "通过不带索引的数组名传递一个指向数组的指针" << endl;
}

void my_func1(int pre[10]) {
    cout << "传递带索引的数组参数" << endl;
}

void my_func2(int pre[]) {
    cout << "传递索引为空的数组参数" << endl;
}

下面举个例子来体会一下

#include <iostream>

using namespace std;

//使用模板类
template<class T>
int get_array_length(T &array);

template<class T>
double get_average(T &arr, int size);

int main() {
    system("chcp 65001");
    int a[10] = {10, 20, 30, 40, 50, 60, 100, 200, 300, 3000};
    int array_length = get_array_length(a);
    double average = 0;
    average = get_average(a, array_length);
    cout << "数组的平均值:" << average << endl;
    return 0;
}

template<class T>
int get_array_length(T &array) {
    return sizeof(array) / sizeof(array[0]);
}

template<class T>
double get_average(T &arr, int size) {
    int sum = 0;
    double average = 0;
    for (int i = 0; i < size; ++i) {
        sum += arr[i];
    }
    average = double(sum) / size;
    return average;
}

Active code page: 65001
数组的平均值:381

动态获取数组长度

#include <iostream>
#include <cstdlib>

using namespace std;
const char NEWLINE = '\n';

template<class T>

int get_array_length(T &array);

int main() {
    system("chcp 65001");
    int a[10];
    int length = 0;
    length = get_array_length(a);
    cout << "数组长度:" << length << endl;
    return 0;
}

template<class T>
int get_array_length(T &array) {
    int array_length = sizeof(array) / sizeof(array[0]);
    return array_length;
}

输出:
Active code page: 65001
数组长度:10

指针占用内存

arr 是一个指针，即为地址，指针占几个字节跟语言无关，而是跟系统的寻址能力有关。
例如：以前是 16 位地址，指针即为 2 个字节，现在一般是 32 位系统，所以是 4 个字节，以后 64 位，则就占 8 个字节。
所以以上介绍的三种方式，获得的指针内存地址都是8个字节，但是如果是模板类，则按照捕获参数的数组类型动态分配,int:4,double:8等等。如果传入的是指针，则还是按照系统的寻址能力分配，也就是8.

#include <iostream>

using namespace std;

template<class T>
int get_array_length(T &array);

template<class T>
double get_average(T &arr, int size);

int main() {
    system("chcp 65001");
    int a[10] = {10, 20, 30, 40, 50, 60, 100, 200, 300, 3000};
    int *pre;
    pre = a;
    cout << "指针pre指向的地址:" << pre << endl << "数组a[0]内存地址:" << &a[0] << endl << "数组a内存地址:" << a << endl;
    int array_length = get_array_length(pre);
    double average = 0;

    average = get_average(pre, array_length);
    cout << "数组的平均值:" << average << endl;
    return 0;
}

template<class T>
int get_array_length(T &array) {
    cout << "模板类中指针参数的内存大小:" << sizeof(array) << endl
         << "模板类中数组第一个参数内存大小:" << sizeof(array[0]) << endl;
    return sizeof(array) / sizeof(array[0]);
}

template<class T>
double get_average(T &arr, int size) {
    int sum = 0;
    double average = 0;

    for (int i = 0; i < size; ++i) {
        sum += arr[i];
    }
    average = double(sum) / size;
    return average;
}

输出:
Active code page: 65001
指针pre指向的地址:0x63fde0
数组a[0]内存地址:0x63fde0
数组a内存地址:0x63fde0
模板类中指针参数的内存大小:8
模板类中数组第一个参数内存大小:4
数组的平均值:15

从函数返回数组

C++函数不能直接返回数组类型，但是数组是指针常量，可以定义指针返回类型来实现。

#include <iostream>
#include <cstdlib>
#include <ctime>

using namespace std;

template<class T>
int *get_random(T &a);

template<class T>
int get_array_length(T &arr);

int main() {
    system("chcp 65001");
    int *p;
    int a[10];
    p = get_random(a);
    cout << "-------------------------------------" << endl;
    for (int i = 0; i < get_array_length(a); ++i) {
        cout << "指针指向的数组元素的值a[" << i << "]:" << *p << endl;
        p++;
    }
    return 0;
}

template<class T>
int *get_random(T &a) {
    cout << a << endl;
    int size = get_array_length(a);
    cout << size << endl;
    srand(unsigned(time(NULL)));

    for (int i = 0; i < size; ++i) {
        a[i] = rand();
        cout << "重新赋值数组元素的值a[" << i << "]:" << a[i] << endl;
    }
    return a;
}

template<class T>
int get_array_length(T &arr) {
    return sizeof(arr) / sizeof(arr[0]);
}

输出:
Active code page: 65001
0x63fde0
10
重新赋值数组元素的值a[0]:24281
重新赋值数组元素的值a[1]:12052
重新赋值数组元素的值a[2]:1185
重新赋值数组元素的值a[3]:1198
重新赋值数组元素的值a[4]:18454
重新赋值数组元素的值a[5]:8739
重新赋值数组元素的值a[6]:6754
重新赋值数组元素的值a[7]:1249
重新赋值数组元素的值a[8]:22626
重新赋值数组元素的值a[9]:16085
-------------------------------------
指针指向的数组元素的值a[0]:24281
指针指向的数组元素的值a[1]:12052
指针指向的数组元素的值a[2]:1185
指针指向的数组元素的值a[3]:1198
指针指向的数组元素的值a[4]:18454
指针指向的数组元素的值a[5]:8739
指针指向的数组元素的值a[6]:6754
指针指向的数组元素的值a[7]:1249
指针指向的数组元素的值a[8]:22626
指针指向的数组元素的值a[9]:16085

1、在循环外面调用srand((unsigned)time(NULL));函数后，函数的参数做为初始种子seed，rand()函数利用初始种子将返回值next做为新的“种子”，保证每次"种子"都不同；
2、假如srand函数放在循环体内部，由于time函数只精确到s，srand函数的参数（初始种子seed）在1s之内不会发生变化，rand()函数利用初始种子生成的返回值next（做为新的“种子”）每次都一样，所以需要放在循环体外面。

#include <iostream>

using namespace std;

float *mul_matrix(float m[4], float a[4], float b[4]);

int main() {
    float a[4] = {1.75, 0.66, 0, 1.75};
    float b[4] = {1, 1, 0, 0};
    // 开辟一个float数组（4个元素）空间，返回首元素的地址
    float *m;
    m = new float[4];
    float *M;
    M = mul_matrix(m, a, b);
    cout << M[0] << endl
         << M[1] << endl
         << M[2] << endl
         << M[3] << endl;
    //释放手动分配的内存,也可以使用free()来释放
    delete[]m;
    //free(m);
    return 0;
}

float *mul_matrix(float m[4], float a[4], float b[4]) {
    m[0] = a[0] * b[0] + a[1] * b[2];
    m[1] = a[0] * b[1] + a[1] * b[3];
    m[2] = a[2] * b[0] + a[3] * b[2];
    m[3] = a[2] * b[1] + a[3] * b[3];
    return m;
}

输出:
1.75
1.75
0
0

1.数组的 delete 是 delete[]。
2.C++ 里面手动内存分配的一个重要原则是谁分配谁释放。所以，不应该在MultMatrix里new数组，而应该在外面new好了之后传进去修改。
3.要想返回一个数组，使用智能指针之类的东西才是正途。

阿吉的CV之路
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++语法——数组
观则明的博客
10-03 2427
C++语法——数组
C++ 数组
风吴痕的博客
10-05 1081
原文地址：http://www.runoob.com/cplusplus/cpp-arrays.html C++ 支持数组数据结构，它可以存储一个固定大小的相同类型元素的顺序集合。数组是用来存储一系列数据，但它往往被认为是一系列相同类型的变量。 数组的声明并不是声明一个个单独的变量，比如 number0、number1、...、number99，而是声明一个数组变量，比如 nu
c++数组及初始化
最新发布
qq_35662333的博客
04-10 118
【代码】c++数组及初始化。
C++数组
m0_46492006的博客
10-16 414
这样写x[3]是double类型，而函数要求的是double*类型就会出错。其中arr是“double*”类型，arr[0]是double类型.
用C++这里写自编写一个程序，初始化一个double类型的数组，然后把该数组的内容 复制至3个其他数组中＜在main()中声明这4个数组＞
ZengYong12138的博客
10-14 300
使用带数组表示法的 函数进行第1份复制。使用带指针表示法和指针递增的函数进行第2份复制。把目标数组名、源数组名和待复制的元素个数作为前两个函数的参数。第3个函数以目标数组名、源数组名和指向源数组最后一个元素后面的元素的指 针。
C++:读写二进制文件到double数组
luoganttcc的博客
02-22 1024
在以下的代码中，我们将写入一个double数组到1.txt中，并且读取出来。 主要采用了fstream这个库，代码如下： link #include <math.h> #include <fstream> #include <iostream> int main(){ const int length = 100; double f1[length] ; for (int i = 0; i < length; i++) {
C++指针 数组 内存释放.docx
11-15
C++指针数组内存释放 C++指针是一种基本变量，包含一个实际的数据，该数据代表一个可以找到实际信息的内存地址。指针是C++编程中非常重要的概念，许多程序和思想依靠指针作为他们设计的基础。 定义指针变量 定义...
C++螺旋数组
06-22
c++螺旋数组
python调用c++传递数组的实例
09-19
本文将深入探讨如何在Python中调用C++函数并传递数组作为参数。 首先，Python使用`ctypes`库来与C/C++动态链接库进行交互。`ctypes`允许我们定义C数据类型，并将它们映射到Python对象。例如，`c_int * 4`表示一个...
C++实现数组类
12-11
C++实现数组类，获取数组长度，数组的输入，数组的输出，数组的复制。
C++数组名扩展
09-09
c++数组方面的知识，不错的函数；可以参考着用
C/C++中的二维数组，以及多维数组及其指针
edward_zcl的博客
04-08 1318
数组是编程语言中常见的数据类型，有必要二维以及多维数组，以及对应的指针，做一个梳理，便于以后查询。 首先你要区分不同的指针，尤其是二级指针与二维数组的行指针，二级指针与指针数组。。 学习编程，最好结合计算机内存一起理解。还是先从最基本的开始。 之前写过一篇二维数组的博客，参考： https://blog.csdn.net/edward_zcl/article/details/89100600 ...
C++:读写二进制文件到double数组,根据二进制数据量进行读取
luoganttcc的博客
02-22 2037
代码和数据在git #include <math.h> #include <fstream> #include <iostream> #include <fstream> #include <iostream> #include <sstream> #include <string> using namespace std; //int readBinFile(std::string& filenam
C++ 中通过sendmesage传递一个double类型数组，一个int型变量
u012719076的博客
04-30 380
void CTestOnCopyDataDlg::OnBnClickedButton1() { // TODO: 在此添加控件通知处理程序代码 double _Laser[3] = { 0 }; _Laser[0] = 1; _Laser[1] = 2; t_Laser[2] = 3; int _Laser_num = 100; ::SendMessage(m_hWnd, WM_RECOVERY_DATA, (WPARAM)_Laser , (LPARAM)_Laser_num); }
知识分享：C/C++函数返回二维数组指针
致力于C语言C++知识分享！
12-13 2008
C/C++从函数返回指针是常规操作，本文针对返回二维数组指针做了一些研究，并给出二维数组指针返回double**类型指针的结论。 常规C/C++函数返回二维数组指针 （1）返回值返回二维数组指针 首先看通过返回值返回二维指针的简单情况： 上述代码中，数据内存从堆(heap)分配，因此函数结束后分配的存储空间依然可用。调用方式： （2）传参返回二维数组指针 一些情况下，我们希望传入一个指针，其在函数内完成内存分配。这个要求稍微复杂点，其代码为： 因为要改变二维指针的指向，传参方.
C++函数返回二维数组
热门推荐
Escape_x1n的博客
08-01 1万+
一、 double (*Getdata())[n] { double(*p1)[n]=new double[3][n]; string data1 = "E:\\215\\0pnp\\pnp代码\\rpnp1.0\\code3\\testpst\\xxv.txt"; string data2 = "E:\\215\\0pnp\\pnp代码\\rpnp1.0\\code3\\testpst\...
C++引用数组
doubleintfloat的博客
11-16 3112
有些书上说，不能建立数组的引用，鄙人不敢苟同。int a= 10; int *p = &a; int &b = a;我发现引用的建立就是把int * p = & a中&和*互相调换，那么数组中是否也可以呢#include<iostream> using namespace std;int main() { int arr[3]={1,2,3}; //int (*p)[3] = &ar
C#与C++编写的dll调用——double数组/一维/二维
kekewf的博客
10-20 1894
C#与C++编写的dll调用——double数组/一维/二维 传入参数 C++:double *——C#:double[] ————————一维数组—————— 先来个 一维的数组， C++代码块： //.cpp //将传入的数组所有值增加1后返回 _declspec(dllexport) void test_double_group(double *test, int num) { int j = 1; for (int i = 0; i <num; i++) { test[i] += 1
C++：传递数组给函数
己亥谷雨
09-12 2225
C++ 中可以通过指定不带索引的数组名来传递一个指向数组的指针。 C++ 传数组给一个函数，数组类型自动转换为指针类型，因而传的实际是地址。 如果想要在函数中传递一个一维数组作为参数，必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。同样地，您也可以传递一个多维数组作为形式参数。 方式 1 形式参数是一个指针： void myFunction(int *param) { } 方式 2 形式参数是一个已定义大小的数组： void my
c++求数组长度数组
11-20
在C++中，可以使用sizeof(array) / sizeof(array[0])来获取数组的长度。其中，sizeof(array)返回整个数组所占用的字节数，而sizeof(array)返回数组中一个元素所占用的字节数。因此，将整个数组所占用的字节数除以一个元素所占用的字节数，就可以得到数组的长度。 以下是一个示例代码： ```c++ #include <iostream> using namespace std; int main() { int arr[] = {1, 2, 3, 4, 5}; int len = sizeof(arr) / sizeof(arr[0]); cout << "The length of the array is: " << len << endl; return 0; } ``` 输出结果为： ``` The length of the array is: 5 ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值