C++中的数组array和vector,lambda表达式,C字符串加操作,C++中新类型数组(数组缓存),多元数组,new缓冲-阿里云开发者社区

开发者社区> 人工智能> 正文
登录阅读全文

C++中的数组array和vector,lambda表达式,C字符串加操作,C++中新类型数组(数组缓存),多元数组,new缓冲

简介:  使用C++风格的数组,不需要管理内存。 array要注意不要溢出,因为它是栈上开辟内存. array适用于任何类型 #include<iostream> #include<array> #include<vector>   //C++的标准库 #include<string

  1. 使用C++风格的数组,不需要管理内存。

  2. array要注意不要溢出,因为它是栈上开辟内存.

  3. array适用于任何类型

#include<iostream>

#include<array>

#include<vector>   //C++的标准库

#include<string>   //C++字符串

#include <stdlib.h>

 

using  std::array; //静态数组,栈上

using std::vector; //动态数组,堆上

using std::string;

 

//使用C++风格数组不需要管理内存。

//array注意不要栈溢出

//array适用于任何类型

 

void main()

{

    array<int, 5> myint1 = { 1, 2, 3, 4, 5 };

    array<int, 5> myint2 = { 11, 12, 13, 14, 15 };

    array<int, 5> myint3 = { 21, 22, 23, 24, 25 };

    //  array<array<int,5>, 3> myint = {myint1,myint2,myint3};

    array<array<int, 5>, 3> myint = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };

    for (int i = 0; i < myint.size(); i++)//数组大小

    {

        for (int j = 0; j < myint1.size(); j++)

        {

            std::cout << "  " << myint[i][j];

        }

        std::cout << "\n";

    }

 

    std::cin.get();

}

  1. vector:动态字符串数组

#include<iostream>

#include<array>

#include<vector>//C++的标准库

#include<string>//C++字符串

#include <stdlib.h>

 

using  std::array;//静态数组,栈上,

using std::vector;//动态数组,堆上,

using std::string;

 

//使用C++风格数组不需要管理内存。

//array注意不要栈溢出

//array适用于任何类型

 

void main()

{

    vector <string>  string1;//动态字符串数组

    //可以反复利用

    string1.push_back("notepad");

    string1.push_back("calc");

    string1.push_back("mspaint");

    string1.pop_back();//删除一个

    //string1.clear();//清空

    for (int i = 0; i < string1.size(); i++)//遍历动态数组

    {

        system(string1[i].c_str());

    }

 

    system("pause");

}

5.通过iterator关键字进行过迭代

#include<iostream>

#include<array>

#include<vector>   //C++的标准库

#include<string>   //C++字符串

#include <stdlib.h>

 

using  std::array; //静态数组,栈上

using std::vector; //动态数组,堆上

using std::string;

 

void main()

{

    vector <string>  string1;//动态字符串数组

    string1.push_back("notepad");

    string1.push_back("calc");

    string1.push_back("mspaint");

 

    vector<string>::iterator ibegin, iend;//迭代器

    ibegin = string1.begin();  //数据起始点

    iend = string1.end();      //结束

    for (;ibegin != iend;ibegin++)

    {

        string tempstr = *ibegin;   //获取指针指向的数据

        system(tempstr.c_str());    //执行指令

    }

 

    system("pauese");

}

6.正逆向迭代数组

#include<iostream>

#include<array>

#include<vector>   //C++的标准库

#include<string>   //C++字符串

#include <stdlib.h>

 

using  std::array; //静态数组,栈上

using std::vector; //动态数组,堆上

using std::string;

 

void main()

{

    array<int, 5> myint = { 1, 2, 3, 4, 5 };

    array<int, 5>::iterator ibegin, iend;//正向迭代器

    ibegin = myint.begin();

    iend = myint.end();

    while (ibegin != iend)

    {

        std::cout << *ibegin << std::endl;

        ibegin++;

    }

    std::cout << "----------" << std::endl;

    array<int, 5>::reverse_iterator rbegin, rend;

    rbegin = myint.rbegin();

    rend = myint.rend();

    while (rbegin != rend)

    {

        std::cout << *rbegin << std::endl;

        rbegin++;

    }

    std::cin.get();

}

7.反向迭代器

#include<iostream>

#include<array>

#include<vector>   //C++的标准库

#include<string>   //C++字符串

#include <stdlib.h>

 

using  std::array; //静态数组,栈上

using std::vector; //动态数组,堆上

using std::string;

 

void main()

{

    vector<string> string1; //动态字符串数组

    string1.push_back("notepad");

    string1.push_back("calc");

    string1.push_back("mspaint");

    //反向迭代器

    vector<string>::reverse_iterator rbegin = string1.rbegin();

    vector<string>::reverse_iterator rend = string1.rend();

    //rend最后不指向数据,指向数据的结尾的下一个节点

    //当使用下面的方法时,只打印了记事本,计算器

    rend--;

    A:if (rbegin != rend)

    {

        system((*rend).c_str());  //执行指令

        //rbegin++;

        rend--;

        goto A;

    }

}

8.lambda表达式,不仅仅适用与array,也适用于vector

#include<iostream>

#include <vector>

#include <algorithm>  //算法 lambda表达式,不仅仅适用于array,也适用于vector

 

void main()

{

    std::vector<int> myvector;

    myvector.push_back(11);

    myvector.push_back(22);

    myvector.push_back(33);

    myvector.push_back(3);

    myvector.push_back(4);

    myvector.push_back(5);

    int res = 0;  //结果

    //&res直接操作一个变量,res等价于返回值,x代表参数,

    //每次充当迭代器指向的元素,大括号就是代码

    std::for_each(myvector.begin(), myvector.end(), [&res](int x){res += x; });

    std::cout << res;

    std::cin.get();

}

运行结果是:

9.vector的增删改查

#include<iostream>

#include <vector>

#include <algorithm>  //算法 lambda表达式,不仅仅适用于array,也适用于vector

 

void main()

{

    //分配5个空间,默认初始化为0

    std::vector<int> myvector(5);

    myvector.push_back(1);

    myvector.push_back(11);

    myvector.push_back(111);

    myvector.push_back(1111);

    myvector.push_back(2);

    //弹出一个元素,删除最后一个

    myvector.pop_back();

    //插入

    myvector.insert(myvector.begin() + 1,999);

    //根据迭代器的位置

    myvector.erase(myvector.begin() + 5);

    //myvector.clear(); //删除所有元素

    for (int i = 0; i < myvector.size();i++)

    {

        if (1)

        {

            //查询,修改

        }

        std::cout << myvector.at(i) << std::endl;

    }

    system("pause");

}

10.vector中的元素也是vector

#include<iostream>

#include <vector>

#include <algorithm>  //算法 lambda表达式,不仅仅适用于array,也适用于vector

 

void main()

{

    //可以实现动态无规则数组管理

    std::vector<int> myvector1;

    myvector1.push_back(12);

    myvector1.push_back(13);

    myvector1.push_back(14);

 

    std::vector<int> myvector2;

    myvector2.push_back(22);

 

    std::vector<int> myvector3;

    myvector3.push_back(32);

    myvector3.push_back(37);

 

    std::vector<std::vector<int>> allvecor;

    allvecor.push_back(myvector1);

    allvecor.push_back(myvector2);

    allvecor.push_back(myvector3);

    for (int i = 0; i < allvecor.size();i++)

    {

        for (int j = 0; j < allvecor[i].size();j++)

        {

            std::cout << "  " << allvecor[i][j];

        }

        std::cout << "\n";

    }

 

    std::cin.get();

}

11.C++中的数组可以直接赋值

#include <iostream>

#include <array>

#include <string>

#include <stdlib.h>

 

void main()

{

    double db[4] = { 1.1, 2.2, 3.3, 4.4 };

    //std::array数据类型,double元素类型,4个数

    std::array<double, 4> dbnew1 = { 10.1, 10.2, 10.3, 10.4 };

    //可以实现数组之间整体操作

    std::array<double, 4> dbnew2 = dbnew1;

    for (int i = 0; i < 4; i++)

    {

        std::cout << db[i] << "   " << dbnew1[i] << "    " << dbnew2[i] << std::endl;

    }

    std::cin.get();

}

运行结果:

12.array的字符串

#include <iostream>

#include<array>

#include<string>

#include<stdlib.h>

 

void main()

{

    std::array<std::string, 5> string1 = { "calc", "notepad", "tasklist", "mspaint", "write" };

    for (int i = 0; i < 5; i++)

    {

        std::cout << string1[i] << std::endl;

        system(string1[i].c_str());

    }

    std::cin.get();

}

12.C++可以加操作

#include <iostream>

#include<array>

#include<string>

#include<stdlib.h>

 

void main()

{

    std::string str1 = "task";

    std::string str2 = "list";

    std::string str3 = str1 + str2;

    system(str3.c_str());

    std::cin.get();

}

13.new的高级,缓冲区

#include<iostream>

#include<new>

const int buf(512);//限定一个常量整数512

int N(5);//数组的长度

char buffer[buf] = { 0 };//静态区

 

//p1,p3,p5作为指针变量在栈区,存储的地址指向堆区

//手动释放内存

 

//p2,p4,p6作为指针变量在栈区,存储的地址在静态区。缓冲区。

//自动释放内存,用于分配用完了就不会再用的数据

//避免内存泄漏,自动释放内存。牺牲了内存访问独立性,

using namespace std;

 

void main()

{

    double *p1, *p2;

 

    std::cout << "\n\n\n";

    p1 = new double[N];//分配内存,N个元素的大小

    p2 = new (buffer)double[N];//指定区域分配内存

    for (int i = 0; i < N; i++)

    {

        p1[i] = p2[i] = i + 10.8;//对于数组初始化

        std::cout << "p1===   " << &p1[i] << "  " << p1[i];

        std::cout << "   p2===  "<< &p2[i] << "  " << p2[i] << std::endl;

    }

 

    double *p3, *p4;

    std::cout << "\n\n\n";

    p3 = new double[N];//分配内存,N个元素的大小

    p4 = new (buffer)double[N];//指定区域分配内存

 

    for (int i = 0; i < N; i++)

    {

        p3[i] = p4[i] = i + 10.8;//对于数组初始化

        std::cout << "p3===   " << &p3[i] << "  " << p3[i];

        std::cout << "   p4===  "<< &p4[i] << "  " << p4[i] << std::endl;

    }

 

    double *p5, *p6;

    std::cout << "\n\n\n";

    p5 = new double[N];//分配内存,N个元素的大小

    p6 = new (buffer)double[N];//指定区域分配内存

 

    for (int i = 0; i < N; i++)

    {

        p6[i] = p5[i] = i + 10.8;//对于数组初始化

        std::cout << "p5===   " << &p5[i] << "  " << p5[i];

        std::cout << "   p6===  "<< &p6[i] << "  " << p6[i] << std::endl;

    }

 

    std::cin.get();

}

14.多元数组

#include <iostream>

#include <map>

 

//void在参数内部意味着参数为空,不写也意味着为空

void main(void)

{

    int int1 = 10;

    double double1 = 99.8;

    char ch = 'A';

    char *str = "hellochina";

    std::tuple<int, double, char, const char *> mytuple(int1, double1, ch, str);

    const int num = 3;

    auto data0 = std::get<0>(mytuple);

    auto data1 = std::get<1>(mytuple);

    auto data2 = std::get<2>(mytuple);

    auto data3 = std::get<num>(mytuple);//下标只能是常量

    std::cout << typeid(data3).name() << std::endl;

    decltype(data0) dataA;   //获取数据类型再次创建

    //mytuple.swap(mytuple); array  vector都有交换的功能

    std::cout << data0 << "  " << data1 << "  " << data2 << "   " << data3 << std::endl;

    std::cin.get();

}

//tuple必须是一个静态数组

//配合vector,array

 

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:
人工智能
使用钉钉扫一扫加入圈子
+ 订阅

了解行业+人工智能最先进的技术和实践,参与行业+人工智能实践项目

其他文章
最新文章
相关文章