精华内容
下载资源
问答
  • #include #include using namespace std; main() { vectorit; double a[100000]; for(int i=0;i { a[i]=i; } cout for(int i=0;i { it.push_back(a[i]); } cout it.clear(); cout vector()

    #include <vector>
    #include <iostream>
    using namespace std;
    main()
    {
    vector<double>it;
    double a[100000];
    for(int i=0;i<100000;i++)
    {
    a[i]=i;
    }
    cout << "未放元素时容器大小为: " << it.size() << "容器容量为: " << it.capacity() << endl; //未放元素
    for(int i=0;i<100000;i++)
    {
    it.push_back(a[i]);
    }
    cout << "放元素后容器大小为: " << it.size() << "容器容量为: " << it.capacity() << endl; //放元素
    it.clear();
    cout << "clear后容器大小为: " << it.size() << "容器容量为: " << it.capacity() << endl; //clear
    vector<double>().swap(it);
    cout << "swap后容器大小为: " << it.size() << "容器容量为: " << it.capacity() << endl; //swap

    return 0;
    }

    展开全文
  • 有一天写着写着代码,突然想到,如果对vector里某个元素设置引用后,将这个元素从vector里删除会怎么样?我思考了下,认为那个元素会被删除,但是引用还是会指向原来的内存,也就是说这里可能会出现安全问题。光想是...

      引用的定义不多说,直接看做变量的别名就可以了。有一天写着写着代码,突然想到,如果对vector里某个元素设置引用后,将这个元素从vector里删除会怎么样?我思考了下,认为那个元素会被删除,但是引用还是会指向原来的内存,也就是说这里可能会出现安全问题。光想是不行的,所以速度写了个小测试:

    #include<iostream>
    #include<vector>
    
    class Test{
    public:
        Test() {
            a = 1;
        }
        
        ~Test() {
            a = 5;
        }
        
        int a;
    };
    
    int main()
    {
        std::vector<Test> vec;
        vec.push_back(Test());
        
        Test &t = vec.back();
        std::cout << t.a << std::endl;
        
        vec.pop_back();
        
        std::cout << t.a << std::endl;
        
        return 0;
    }

      输出如下:

    1
    5

      是的,很明显,引用指向的元素被析构了。以前我是从没注意过这一块的,嗯,又发现了一个日常可能出错的地方。

    转载于:https://www.cnblogs.com/RookieSuperman/p/11257533.html

    展开全文
  • vector<string> vec; //初始化mpi if(myid == 0) { vec.push_back("d:/mpi/01.las"); vec.push_back("d:/mpi/02.las"); vec.push_back("d:/mpi/03.las"); vec.push_back("d:/mpi/04.las"); MPI_Send...
  •  To use the vector array, you first will need to include the <vector> header file. In older versions of Microsoft Visual C++ (2002 and below), you can either include the <vector> header or the ...

     我只听见硬盘 嘎吱嘎吱地响,Window 98已累患上对键盘、鼠标一无反映

      总的说来,C/C++的内存办理照旧太庞大了,步伐员忙这些个工作就够了,没法搞出Java同样更“高级”的庞大工具了

      ----------------------------------

      Environment: VC5, VC6, VC7.NET, WinXP, Win2000, Win98, NT4 SP3

      What Is the std::vector Array?

      The vector array is part of the standard namespace (std::); it allows you to easily create a dynamic array of elements. The vector class belongs to the STL (Standard Template Libraries) and is a template class in itself; this means that we can create an array of almost any data-type or object within our programs when using it. The vector class handles most of the memory management for you. When Might You Use a Vector Array?

      A vector array would be ideal in a situation where you need to store dynamic data; for example, an array that changes in size during the program''s execution. How Do You Use the Vector Array?

      To use the vector array, you first will need to include the <vector> header file. In older versions of Microsoft Visual C++ (2002 and below), you can either include the <vector> header or the <vector.h> header; the <vector.h> header was removed in Microsoft Visual C++ 7.1 (2003). Then, you will need to actually create your array. Here is an example of the declaration of an array of integers: // VectorTest.cpp

      //

      // files to include

      #include <stdio.h> // standard input/output

      #include <vector> // stl vector header

      using namespace std; // saves us typing std:: before vector

      void main()

      {

      // create an array of integers

      vector<int> arNumbers;

      }

      Notice that, when declaring an array of integers, we first type "vector" which, as with the use of any class, indicates that we want to create an object of that type. We then place the data-type "int" within sharp brackets to indicate that we want to create an array of integers. When creating template classes, a very important factor is being able to specify additional information to the class; this information is specified within the sharp brackets. Then, we simply state the name (arNumbers) we want to give our array and terminate the statement with a semicolon. Then, to add elements to this array, we call the vectors "push_back" member function; this basically appends a new element of the data-type originally specified (in this case "int") to the end of the array. Here is an example where we add four elements to our array: // same as in previous code sample above

      void main()

      {

      // create an array of integers

      vector<int> arNumbers;

      // add four elements to our array

      arNumbers.push_back⑿;

      arNumbers.push_back(24);

      arNumbers.push_back(36);

      arNumbers.push_back(48);

      }

      It then is possible to retrieve this information again by using a very similar method to that used with standard arrays. The following code sample extends the previous section beneath the line "arNumbers.push_back(48);": // get the total amount of elements within the array

      int nArraySize = (int)arNumbers.size();

      // display the total amount of elements on the screen

      printf("Total Elements: %d\n\n", nArraySize);

      // display the array''s contents on the screen

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

      printf("Value at position %d is %d\n", i, arNumbers[i]);

      }

      First of all, I have found out the total amount of elements within our vector array; this was done by calling the size() function. Here we also have added a typecast of an integer; this has been done to prevent the compiler from giving us a warning. I then have added a line of code that basically displays the total amount of elements within the array. We have then got a loop that iterates through all of the elements within the array. As with the standard static arrays, it is possible to use the ''['' and '']'' operators to access an element at a specific position. Using the Vector Classes Iterators

      The vector class has its own specialised iterators that can be used to access information in the array. Many of the vector classes'' member functions require you to input one of these iterators, an example of a function that uses iterators is the erase() function. The erase() function is used to remove one or more elements from the array. To declare an iterator that is compatible with your vector array, you will need to do something like the following: vector<int>::iterator NumIt

      An iterator is basically like a pointer to the position in memory where the data within the array is stored. To access the value at a given reference, you will need to use the asterisk symbol to dereference the pointer. Here is an example of using these iterators within vector arrays: // VectorTest.cpp

      //

      // files to include

      #include <stdio.h> // standard input/output

      #include <vector> // stl vector header

      using namespace std; // saves us typing std:: before vector

      void main()

      {

      // create an array of integers

      vector<int> arNumbers;

      // add four elements to our array

      arNumbers.push_back⑿;

      arNumbers.push_back(24);

      arNumbers.push_back(36);

      arNumbers.push_back(48);

      // get the total amount of elements within the array

      int nArraySize = (int)arNumbers.size();

      // display the total amount of elements on the screen

      printf("Total Elements: %d\n\n", nArraySize);

      // create a vector<int>::iterator and set the position to which

      // it points to the beginning of the vector array in memory

      vector<int>::iterator itNum = arNumbers.begin();

      // Now, we iterate through the array until the iterator exceeds

      // the end of the array. You will notice that in this for loop

      // I have left out the initialisation section; this is

      // because it has been done separatly before.

      for(; itNum < arNumbers.end(); itNum++)

      printf("Value at position %d is %d\n",

      (int)(itNum - arNumbers.begin()), *itNum);

      }

      In this scenario, we have calculated the position of each element within the array simply by taking the beginning of the array from the current iterator. So basically, we find how far away from the beginning of the array we are from the current iterator, which is clearly the same value as the index position as within the previous example. So, now we are going to extend our knowledge by removing the second element of the array (this will be done before the code displaying the contents of the array so that you can see what is happening). // VectorTest.cpp

      //

      // files to include

      #include <stdio.h> // standard input/output

      #include <vector> // stl vector header

      using namespace std; // saves us typing std:: before vector

      void main()

      {

      // create an array of integers

      vector<int> arNumbers;

      // add four elements to our array

      arNumbers.push_back⑿;

      arNumbers.push_back(24);

      arNumbers.push_back(36);

      arNumbers.push_back(48);

      // remove the second element from the array, what we say

      // looks like element 1, but because we start counting from

      // 0 it is actually element 2 because 0 represents element 1

      vector<int>::iterator itRemove = arNumbers.begin() + 1;

      // now, actually remove this element from the array

      arNumbers.erase(itRemove);

      // get the total amount of elements within the array

      int nArraySize = (int)arNumbers.size();

      // display the total amount of elements on the screen

      printf("Total Elements: %d\n\n", nArraySize);

      // get an iterator to the start of the numbers array

      vector<int>::iterator itNum = arNumbers.begin();

      // display the arrays'' contents

      for(; itNum < arNumbers.end(); itNum++)

      printf("Value at position %d is %d\n",

      (int)(itNum - arNumbers.begin()), *itNum);

      }

      /* Program''s Output:

      ================

      Total Elements: 3

      Value at position 0 is 12

      Value at position 1 is 36

      Value at position 2 is 48

      Press any key to continue

      */

      It is also possible to remove a whole range of elements simply by specifying a starting iterator and an ending iterator, as in the following: arNumbers.erase(itStart, itEnd);

      Clearing the Entire Vector Array

      The clear() member function of the vector array can be used to clear all of the elements from the array. Be aware, if the array contained points to memory that was created dynamically, i.e. the new operator was used, the memory will not be freed, therefore causing a memory leak. So, you would need to make sure that you called the delete operator for each element within the array before calling the clear() function. Here is an example: // same as before

      class CMyClass

      {

      public:

      CMyClass() {}

      CMyClass(int def_x, int def_y) : x(def_x), y(def_y) {}

      virtual ~CMyClass() {}

      // this classes member functions

      // ...

      // some data (i.e. x and y)...

      int x, y;

      };

      void main()

      {

      // create an array of CMyClass object pointers

      vector<CMyClass*> arMyClass;

      // dynamically add some elements (use new operator)

      arMyClass.push_back(new CMyClass(2, 40));

      arMyClass.push_back(new CMyClass(4, 60));

      arMyClass.push_back(new CMyClass(6, 80));

      arMyClass.push_back(new CMyClass(8, 100));

      // remove the second element from the array

      vector<CMyClass*>::iterator itSecond = arMyClass.begin() + 1;

      delete *itSecond; // free the memory

      arMyClass.erase(itSecond); // remove from

      // the array

      // retrieve the value stored within the first x and y variables

      vector<CMyClass*>::iterator itFirst = arMyClass.begin()/* + 0 */;

      printf("First Coordinate: (%d, %d)\n", (*itFirst)->x,

      (*itFirst)->y);

      // start from the beginning of the array

      vector<CMyClass*>::iterator itPos = arMyClass.begin();

      // clear all elements from the array

      for(; itPos < arMyClass.end(); itPos++)

      delete *itPos; // free the element from memory

      // finally, clear all elements from the array

      arMyClass.clear();

      }

      It can be argued that it is much more efficient to create all elements dynamically (with the new operator) because when iterating through the vector array, the computer will only be iterating through the size of a pointer (usually between 2 and 4 bits of memory) as opposed to iterating through very large objects. This is only really essential for 软体 that needs to run very fast, i.e. games or real-time 软体. Remember that you will not need to free the memory (i.e. use the delete operator) if you have not dynamically allocated the memory (i.e. used the new operator). If you are simply storing a vector array of pointers to memory that is either static or cleaned up at a later stage, dynamically freeing the memory will not be an issue for you. If you need to perform large tasks with a vector array, it might be a good idea if you create a class that holds the vector array, but handles the processes that you might wish to perform on the array. Conclusion

      This article just poses as a means for you to get started with std::vector arrays; with practice, you will discover all sorts of different shortcuts and techniques that are available to you. There are also many different STL functions available that allow you to sort the arrays and so forth. I have always enjoyed learning new concepts which is one of the things which suits me to programming, because in programming you are always learning new and interesting concepts. I have been programming since about 1995 and have become reasonably experienced with Microsoft Visual Basic 4,5,6 and Microsoft Visual C++ 5,6,7,7.1. Having achieved a double A grade in AVCE ICT I have begun to study BEng Games and Entertainment Systems Engineering at the University of Greenwich at Medway. I have now completed my first year with the kind of results expected from a first-class degree.

      ----------------------------------

      巨大的Bill Gates 曾掉言:

      640K ought to be enough for everybody — Bill Gates 1981

      步伐员们时常编著内存办理步伐,往往胆战心惊如 果不想触雷,独一的处理完成措施就是发明所有暗藏的地雷而且解除它们,躲是躲没完的这篇文章的内部实质意义比一般教本的要深切患上多,读者需仔细阅览,做到真正地通晓内 存办理

      一、内存分配体式格局

       内存分配体式格局有三种:

      (1)从静态储存地区范围分配 内存在步伐编译的时辰就已分配好,这块内存在步伐的全般运行时期都存在例如整个的局面:胸怀~变量,static变量

      (2)在栈上始于在执 行函数时,函数内局部变量的储储存单子位均可以在栈上始于,函数执行竣事时这些个储储存单子位不佣人的劳力被开释栈内存分配运算内置于措置惩罚器的指令集中,效率很高,可是分 配的内存容积有限

      (3) 从堆上分配,亦称动态内存分配步伐在运行的时辰用malloc或new声请肆意几多的内存,步伐员本身卖力在什么时候用free或delete开释内存动 态内存的保存期由咱们决议,施用很是矫捷,但需要解答的题目也至多

      二、常见的内存纰缪及其对策

       发生内存错 误是件很是贫苦的工作编译器不克不及不佣人的劳力发明这些个纰缪,凡是是在步伐运行时才气捕获到而这些个纰缪大部分没有较着的症状,隐现,增长了改错的困难程度有时候用 户肝火冲冲地把你找来,步伐却没有发生不论什么需要解答的题目,你一走,纰缪又爆发了 常见的内存纰缪及其对策如次:

      * 内存分配未乐成,却施用了它

      编程新手常犯这类纰缪,因为她们没成心识到内存分配会不乐成经常使用处理完成措施是,在施用内存以前查抄指针 是不是为灭茬要是指针p是函数的参量,那末在函数的进口处用assert(p!=灭茬)举行

      查抄要是是用malloc或 new来声请内存,应该用if(p==灭茬) 或if(p!=灭茬)举行防错措置惩罚

      * 内存分配虽则乐成,可是尚未初始化就援用它

      犯这类纰缪首要有两个因由:一是没有初始化的不雅念;二是误认为内存的缺省初值全为零,引起援用初值纰缪(例按原来的数目组) 内存的缺省初值事实是啥子并无同一的规范,只管有些时辰为零值,咱们宁肯托其无不成信其有以是不管用何种体式格局始于数组,都别忘了赋初值,即即是赋零值 也不成省略,不要嫌贫苦

      * 内存分配上音乐成而且已初始化,但操作越过了内存的界限

      例如在施用数组时时常发生 下标“多1”或“少1”的操作出格是在for轮回语句中,轮回民数很容易搞错,引起数组操作越界

      * 健忘了开释内存,造成内存泄露

      含有这类纰缪的函数每一被挪用一次就丢掉一块内存刚起头时体系的内存充沛,你看不到纰缪终有一次程 序俄然死掉,体系浮现提醒:内存耗尽

      动态内存的声请与开释必需交尾,步伐中malloc与free的施用回数必然要么异,不然必定 有纰缪(new/delete同理)

      * 开释了内存却接续施用它

      有三种环境:

      (1) 步伐中的对象挪用瓜葛过于庞大,其实难于搞清晰某个对象事实是不是已开释了内存,此时应该从头预设数值布局,从底子上处理完成对象办理的杂乱场合场面

      (2)函数的return语句写错了,注重不要归回指向“栈内存”的“指针”或“援用”,因为该内存在函数体竣事时被不佣人的劳力毁掉

      (3)施用free或delete开释了内存后,未将指针配置为灭茬引起孕育发生“野指针”

      【法则1】用malloc或new 声请内存然后,应该当即查抄指针值是不是为灭茬防止施用指针值为灭茬的内存

      【法则2】不要健忘为数组和动态内存赋初值防 止将未被初始化的内存作为右值施用

      【法则3】制止数组或指针的下标越界,出格要把稳发生“多1”或“少1”操作

      【法则4】动态内存的声请与开释必需交尾,防止内存走漏

      【法则5】用free或delete开释了内存然后,当行将指针配置为 灭茬,防止孕育发生“野指针”

      三、指针与数组的相比较

       C /C步伐中,指针和数组在不少处所可以彼此替代着用,让人孕育发生一种错觉,认为二者是等价的

      数组要么在静态储存区被始于(如整个的局面:胸怀~数 组),要么在栈上被始于数组名对应着(而不是指向)一块内存,其地址与容积在生命期内连结稳定,只有数组的内部实质意义可以转变

      指针可以 任什么时候间指向肆意类型的内存块,它的特征是“可变”,以是咱们经常使用指针来操作动态内存指针远比数组矫捷,但也更伤害

      底下以字符串为例 比力指针与数组的特征

      3.1 修改内部实质意义

      举出例子3-1中,字符数组a的容积是六个字符,其内部实质意义为hia的内部实质意义可以转变,如a[0]= ‘X’指针p指向恒量字符串“world”(位于静态储存区,内部实质意义为world),恒量字符串的内部实质意义是不成以被修改的从语法上看,编译器其实不感觉语句 p[0]= ‘X’有啥子不当,可是该语句诡计修改恒量字符串的内部实质意义而引起运行纰缪

      举出例子3.1 修改数组和指针的内部实质意义

      3.2 内部实质意义复制与比力

      不克不及对数组名举行直接复制与比力举出例子7-3-2中,若想把数组a的内部实质意义复制给数组b,不克不及用语句 b = a ,不然将孕育发生编译纰缪应该用规范库函数strcpy举行复制同理,比力b和a的内部实质意义是不是不异,不克不及用if(b==a) 来判断,应该用规范库函数strcmp举行比力

      语句p = a 其实不克不及把a的内部实质意义复制指针p,而是把a的地址赋给了p要想复制a的内部实质意义,可以先用库函数malloc为p声请一块容积为strlen(a) 一个字符的内存,再用strcpy举行字符串复制同理,语句if(p==a) 比力的不是内部实质意义而是地址,应该用库函数strcmp来比力

      // 数组…

      char a[] = "hi";

      char b[10];

      strcpy(b, a); // 不克不及用 b = a;

      if(strcmp(b, a) == 0) // 不克不及用 if (b == a)

      …

      // 指针…

      int len = strlen(a);

      char *p = (char *)malloc(sizeof(char)*(len 1));

      strcpy(p,a); // 不要用 p = a;

      if(strcmp(p, a) == 0) // 不要用 if (p == a)

      …

      举出例子3.2 数组和指针的内部实质意义复制与比力

      3.3 计较内存容积

      用运算符sizeof可以计较出数组的容积(字节数)举出例子7-3-3(a)中,sizeof(a)的值是12(注重别忘了’’)指针p指向a,可是 sizeof(p)的值倒是4这是因为sizeof(p)获患上的是一个指针变量的字节数,至关于sizeof(char*),而不是p所指的内存容积 C /C语言没有措施懂患上指针所指的内存容积,错非在声请内存时记住它

      注重当数组作为函数的参量举行通报时,该数组不佣人的劳力退化为同类 型的指针举出例子7-3-3(b)中,岂论数组a的容积是几多,sizeof(a)始末等于sizeof(char *)

      举出例子3.3(b) 数组退化为指针 四、指针参量是如何通报内存的?

       要是函数的参量是一个指针,不要指望用该指针去声请动态内存举出例子 7-4-1中,Test函数的语句GetMemory(str, 200)并无使str获患上指望的内存,str依旧是灭茬,为啥子?

      举出例子4.1 试图用指针参量声请动态内存

      弊端出在函数GetMemory中编译器老是要为函数的每个参量建造姑且副本,指针参量p的副本是 _p,编译器使 _p = p要是函数体内的步伐修改了_p的内部实质意义,就引起参量p的内部实质意义作响应的修改这就是指针可以用作输出参量的缘故原由在本例中,_p声请了新的内存,只是把 _p所指的内存地址转变了,可是p涓滴未变以是函数GetMemory其实不克不及输出不论什么工具事实上,每一执行一次GetMemory就会泄露一块内存,因 为没有效free开释内存

      要是非患上要用指针参量去声请内存,那末应该改用“指向指针的指针”,见举出例子4.2

      举出例子4.2用指向指针的指针声请动态内存

      因为“指向指针的指针”这个观点不易理解,咱们可以用函数归回值来通报动态内存这类要领越发简略,见举出例子4.3

      举出例子4.3 用函数归回值来通报动态内存

      用函数归回值来通报动态内存这类要领虽则好用,可是每一每一有人把return语句 用错了这搭夸大不要用return语句归回指向“栈内存”的指针,因为该内存在函数竣事时不佣人的劳力消亡,见举出例子4.4

      举出例子4.4 return语句归回指向“栈内存”的指针

      用调试器慢慢跟踪Test4,发明执行str = GetString语句后str再也不是灭茬指针,可是str的内部实质意义不是“hi world”而是乐瑟

      要是把举出例子4.4改写成举出例子 4.5,会怎么样?

      举出例子4.5 return语句归回恒量字符串

      函数Test5运行虽则不会堕落,可是函数GetString2的预设观点倒是纰缪的因为GetString2内的“hi world”是恒量字符串,位于静态储存区,它在步伐生命期内永恒固定稳定不管啥子时辰挪用GetString2,它归回的始末是同一个“只读”的内存块

      五、杜绝“野指针”

       “野指针”不是灭茬指针,是指向“乐瑟”内存的指针人们一般不会错用灭茬指针,因为用 if语句很容易判断可是“野指针”是很伤害的,if语句对它失灵用 “野指针”的成因首要有两种:

      (1)指针变量没有被初始 化不论什么指针变量刚被始于时不会不佣人的劳力成为灭茬指针,它的缺省值是RAND的,它会乱指一气以是,指针变量在始于的同时该当被初始化,要么将指针配置为 灭茬,要么让它指向正当的内存例如

      (2)指针p被free或delete然后,没有置为灭茬,让人误认为p是个正当的指针

      (3)指针操作逾越了变量的效用范 围这类环境让人防不堪防,举出例子步伐如次:

      函数Test在执行语句p->Func()时,对象a 已消掉,而p是指向a的,以是p就成为了“野指针”但稀罕的是我运行这个步伐时居然没有堕落,这有可能与编译器关于

      六、有了malloc/free为啥子还要new/delete?

       malloc与free是C /C语言的规范库函数,new/delete是C 的运算符它们均可用于声请动态内存和开释内存

      对非内部数值类型的对象而言,光用maloc/free没有办法餍足动态对象的要求对象在始于的同时要么佣人的劳力执行机关函数,对象在消亡以前要么佣人的劳力执行析构 函数因为malloc/free是库函数而不是运算符,不在编译器节制职权范围以内,不克不及够把执行机关函数和析构函数的使命强迫接受于malloc/free

      是以C 语言需要一个能完成动态内存分配和初始化工作的运算符new,和一个能完成清算与开释内存工作的运算符delete注重new/delete不是库函 数咱们先看一看malloc/free和new/delete如何使成为事实对象的动态内存办理,见举出例子6

      class Obj

      {

      public :

      Obj(void){ cout << “Initialization” << endl; }

      ~Obj(void){ cout << “Destroy” << endl; }

      void Initialize(void){ cout << “Initialization” << endl; }

      void Destroy(void){ cout << “Destroy” << endl; }

      };

      void UseMallocFree(void)

      {

      Obj *a = (obj *)malloc(sizeof(obj)); // 声请动态内存

      a->Initialize(); // 初始化

      //…

      a->Destroy(); // 断根工作

      free(a); // 开释内存

      }

      void UseNewDelete(void)

      {

      Obj *a = new Obj; // 声请动态内存而且初始化

      //…

      delete a; // 断根而且开释内存

      }

      举出例子6 用malloc/free和new/delete如何使成为事实对象的动态内存办理

      类Obj的函数Initialize摹拟了机关函数的功效,函数Destroy摹拟了析构函数的功效函数UseMallocFree中,因为 malloc/free不克不及执行机关函数与析构函数,必需挪用成员函数Initialize和Destroy来完成初始化与断根工作函数 UseNewDelete则简略患上多

      以是咱们不要诡计用malloc/free来完成动态对象的内存办理,应该用new /delete因为内部数值类型的“对象”没有机关与析构的历程,对它们而言malloc/free和new/delete是等价的

      既是new/delete的功效纯粹笼罩了malloc/free,为啥子C 不把malloc/free裁减出局呢?这是因为C 步伐时常要挪用C函数,而C步伐只能用malloc/free办理动态内存

      要是用free开释“new始于的动态对象”,那末该对象因没有办法执行析构函数而有可能引开始走伐堕落要是用delete开释“malloc声请的动态内存 ”,意见上讲步伐不会堕落,可是该步伐的可读性很差以是new/delete必需交尾施用,malloc/free也同样

      七、 内存耗尽怎么办?

       要是在声请动态内存时找不到足够大的内存块,malloc和new将归回灭茬指针,宣告内存声请掉败 凡有三种体式格局措置惩罚“内存耗尽”需要解答的题目

      (1)判断指针是不是为灭茬,要是是则顿时用return语句终止本函数例如:

      (2)判断指针是不是为灭茬,如 果是则顿时用exit⑴终止全般步伐的运行例如:

      (3)为new和malloc配置异样措置惩罚函数例如Visual C 可以用_set_new_hander函数为new配置用户本身界说的异样措置惩罚函数,也能够让malloc享用与new不异的异样措置惩罚函数具体内部实质意义请参 考C 施用手册

      上面所说的(1)(2)体式格局施用最遍及要是一个函数内有多处需要声请动态内存,那末体式格局(1)就显患上力有未逮(开释内 存很贫苦),应该用体式格局(2)来措置惩罚

      人们不忍用exit⑴,问:“不编著堕落措置惩罚步伐,让操作体系本身处理完成行不行?”

      不行要是发生“内存耗尽”如许的工作,一般说来应用步伐已无药可救要是不消exit⑴ 把坏步伐杀死,它有可能会害死操作体系原理犹如:要是不把暴徒搞死,暴徒在老死以前会犯下更多的罪

      有一个很重要的征象要告诉各人对32位以上的应用步伐而言,不管如何施用malloc与new,险些不成能引起“内存耗尽”我在Windows 98下用Visual C 编著了实验步伐,见举出例子7这个步伐会无休止地运行下去,底子不会终止因为32位操作体系撑持“虚存”,内存用完了,不佣人的劳力用硬盘空间顶替

      我可以患上出恁地一个论断:对32位以上的应用步伐,“内存耗尽” 纰缪措置惩罚步伐一无用法这下可把Unix和Windows步伐员们乐坏了:横竖纰缪措置惩罚步伐失灵用,我就不写了,省了许多贫苦

      我 不想误导读者,必需夸大:不加纰缪措置惩罚将引开始走伐的质量很差,万万不成因小掉大

      八、malloc/free 的施用要端

       函数malloc的原形如次:

      咱们该当把注重力集中在两个要素上:“类型转换”和“sizeof”

      * malloc归回值的类型是void *,以是在挪用malloc时要显式地举行类型转换,将void * 转换成所需要的指针类型

      * malloc函数本身其实不辨认要声请的内存是啥子类型,它只体贴内存的总字节数咱们凡是记不住int, float等数值类型的变量简直切字节数例如int变量在16位体系下是二个字节,在32位下是四个字节;而float变量在16位体系下是四个字节, 在32位下也是四个字节最佳用以下步伐作一次实验:

      为啥子free 函数不象malloc函数那样子庞大呢?这是因为指针p的类型和它所指的内存的容积事前都是懂患上的,语句free(p)能不错地开释内存要是p是 灭茬指针,那末free对p不管操作几屡次都不会出需要解答的题目要是p不是灭茬指针,那末free对p持续操作两次就会引开始走伐运行纰缪

      九、new/delete 的施用要端

       运算符new施用起来要比函数malloc简略患上多,例如:

      这是因为new内置了sizeof、类型转换和类型安全查抄 功效对非内部数值类型的对象而言,new在始于动态对象的同时完成为了初始化工作要是对象有多个机关函数,那末new的语句也能够有多种情势例如

      要是用new始于对象数组,那末只能施用对象的无参量机关函数例如

      在用delete开释对象数组时,寄望不要丢了符号‘[]’例如

      后者至关于delete objects[0],遗漏了别的99个对象

      十、一些心患上领会

       我熟悉不少技能不错的C /C步伐员,很少有人能拍拊膺脯说通晓指针与内存办理(包孕我本身)我最初进修C语言时出格怕指针,引起我研发熬头个应用软件(约1万行C代码)时没有 施用一个指针,全用数组来顶替指针,其实蠢笨患上过度遁藏指针不是措施,厥后我改写了这个软件,代码量由大变小到原先的半壁

      我的经验教 训是:

      (1)越是怕指针,就越要施用指针不会不错施用指针,必定算不上是及格的步伐员

      (2)必需养成“施用 调试器慢慢跟踪步伐”的习气,只就象许才气发明需要解答的题目的素质

    展开全文
  • c++ 结构体和vector进行lower_bound和upper_bound

    万次阅读 多人点赞 2018-09-26 12:20:58
    介绍结构体数组和包含结构体的vector怎么样使用lower_bound进行二分查找,upper_bound同理。 前提: lower_bound:返回数组中第一个大于等于该元素的下标,int aa = lower_bound(array,array+arrayLen,num) - array...

    总述:

    介绍结构体数组和包含结构体的vector怎么样使用lower_bound进行二分查找,upper_bound同理。

    前提:

    lower_bound:返回数组中第一个大于等于该元素的下标,int aa = lower_bound(array,array+arrayLen,num) - array;

    upper_bound:返回数组中第一个大于该元素的下标:int aa = upper_bound(array,array+arrayLen,num) - array;

    结构体中查找:

    把我们需要查找的数封装成一个结构体。然后才可以在结构体重进行查找。即使我们只需要针对某一维进行查找,也需要把整个结构体构造出来。

    代码如下:

    struct MY{
        int a,b;
        MY(){}
        MY(int a,int b):a(a),b(b){}
        bool operator<(const MY m)const{ //定义比较方式,这一步很重要
            return a<m.a;
        }
    };
    
    int main(){
        MY m[10];
        for(int i=0;i<10;i++){
            m[i] = MY(i+1,2*i);
            cout<<m[i].a<<"  "<<m[i].b<<endl;
        }
        cout<<"请输入你需要查找的数字a:"<<endl;
        int num;
        cin>>num;
        sort(m,m+10);//进行二分之前需要排序
        int aa =  lower_bound(m,m+10,MY(num,0)) - m;  //需要把我们查找的数封装成一个结构体才能进行查找。
        cout<<"查到位置为:"<<aa<<endl;
        return 0;
    }

    这里我只需要查找第一维,并且我对第一维进行了排序,只有有序数列才可以进行二分,然后在查找的时候,把其他维置零即可。但是必须要封装成一个结构体

    vector中也是同理:

    代码:

    struct MY{
        int a,b;
        MY(){}
        MY(int a,int b):a(a),b(b){}
        bool operator<(const MY m)const{ //定义比较方式,这一步很重要
            return a<m.a;
        }
    };
    
    int main(){
        vector<MY>ve;
        for(int i=0;i<10;i++){
            ve.push_back(MY(i+1,2*i));
            cout<<ve[i].a<<"  "<<ve[i].b<<endl;
        }
        cout<<"请输入你需要查找的数字a:"<<endl;
        int num;
        cin>>num;
        sort(ve.begin(),ve.end());//进行二分之前需要排序
        int aa =  lower_bound(ve.begin(),ve.end(),MY(num,0)) - ve.begin();  //需要把我们查找的数封装成一个结构体才能进行查找。
        cout<<"查到位置为:"<<aa<<endl;
        return 0;
    }

    ve.begin()指向vector的开始,ve.end()指向vector的结尾。

    结果如下:

    以上

    展开全文
  • vector和list

    2012-07-24 22:18:10
    如果在前端或中部安插或删除元素,性能就不怎么样了;因为操作点之后的每一个元素都必须移到另一个位置,而每一次移动都得调用assignment(赋值)操作符。 list: 存取是按顺序来,但是删除的时候是常数时间。 ...
  • C++ std::vector元素的内存分配问题

    千次阅读 2016-01-17 22:11:00
    其内存分配是怎么样的呢?std::vector<T> vec; std::vector* Vec = new std::vector(); std::vector*> vec;首先,说结论吧: 对于std::vector<T> vec;vec在栈上(stack),而其中的元素T保存在堆上(heap);
  • IT之家 9 月 15 日消息 惠普在今年夏天早些时候...惠普鼠标怎么样(2020最新款惠普鼠标测评) 惠普宣称,30 秒的充电时间就可以获得一个小时的电池续航时间,5 分钟的充电时间应该足以撑过一整天,而 15 分钟则可以获得
  • vector用完内存空间后会怎么样? 也就是说,如果我们不断的申请vector空间会怎么样?其实这个问题想想就知道最后肯定会出错嘛,但是既然别人问了而且网上也没有人说明类似的问题,那我们还是做实验来解决嘛。 代码...
  • vector常用方法

    2008-05-13 22:23:00
    可是如果你在前面或者中部安插或元素元素,性能就不怎么样了,因为操作点之后的每一个元素都必须移动另一个位置,而每一次移动都得调用assignment(赋值)操作符。在内存分配方面,可以使用reserve(),保留
  • 之前博客讲了一些关于std::find和std::find_ if的一些用法,但是没有讲述对于vector中存储的是自定义的类,那么怎么样使用std::find和std::find_if进行查找呢?先定义一个类:class Item { private: std::string m_...
  • C++模板库之Vector

    2018-07-23 17:27:00
    如果是在末端添加或者删除元素,那么它的效果是非常好的,但是如何是在前端或者中段添加或删除元素,那么它的效率就不怎么样了。 vector的容量是至关重要的,因为一旦重新分配内存,vector元素相关的reference,...
  • vector vector是表示可变大小数组的序列容器。vector采用连续存储空间...怎么样,是不是心动啦? 简单应用 vector用起来还是比较方便的,也有着优势,所以我大致整理了一下比较实用的vector函数,放在代码中实现(超...
  • 如何求解一个sentence vector的表达?过去,我们常见的就是从word vector到sentence vector,这种从小unit到大一级unit的方法,统一称为“composion”;这方面的工作有以下的1、2、3、4、5、6.1、7。其实,除了以上...
  • 题目:使用hashmap 插入数据,怎么样依照插入数据的顺序输出数据 分析: 使用hashmap插入数据,数据的顺序会改变。能够写个小程序试试。 那怎么样依照插入的顺序输出呢? 方法一: 这是我第一时间想出来的办法: ...
  • 不能将“this”指针从“const Vector3D”转换为“Vector3D &" 错误 我在VS2005中编译Vector3D类出现error C2662: “Vector3D::dotP”: 不能将“this”指针从“const Vector3D”转换为“Vector3D &”怎么样改正呢...
  • 答案:购买过程就是选择好物品放入购物车然后结账import java.util.Vector;public class gouwuche {/*** @param args*/private static Vector vec = new Vector();public static void gw(String name,int price,int ...
  • <div><p><a href="https://github.com/ipkn/crow">crow</a>... //libgo怎么样调度协程比较合适? </code></pre> 初学者,恳请指教,万分感谢</p><p>该提问来源于开源项目:yyzybb537/libgo</p></div>
  • 怎么样减少模板特化的代码臃肿

    千次阅读 2013-03-18 18:47:45
    比如我们有一个Vector模板,我们需要存放int*,double*,char*三种不同的参数,这是就会产成出三套代码,显然这是导致臃肿的原因。  下面看一个例子。 #include using namespace std; template class zVector {...
  • 我们在使用STL中的vector构造结构体的时候或者看别人的代码时如果出现以下的情况,我们想知道其内部构造是怎么样的(不说了,直接上代码上图): typedef struct{ double x,y; vector<int> adjnodes; ...
  • 当对vector进行push_back等操作的时候,当超出之前内存所...那么这个过程是怎么样的呢?我们用代码来试一下: VS2013环境下如下: #include<iostream> #include<vector> using namespace std; int ...
  • 题目:使用hashmap 插入数据,怎么样按照插入数据的顺序输出数据 分析: 使用hashmap插入数据,数据的顺序会改变。可以写个小程序试试。 那怎么样按照插入的顺序输出呢? 方法一: 这是我第一时间想...
  • vec.push_back(n)时,vec的首地址会怎么样变化? */ cout *itVec ;//这句代码运行报错 ``` 我的理解是: 如果定义了空的 vec 对象后,对其进行push_back()操作,由于push_back并非开辟连续内存,导致 vec ...
  • 出于性能的考虑,在跑模型前通常将数据预处理完毕后,先将组装好的SparseVector特征写入到hive表,这个时候就会遇到怎么用hive表存储复杂类型的Vector了。 首先看一下,SparseVector长什么,有如下两种: # 格式一...
  • 博客一:转载自...那么,在一个成熟的类库里面,它的实现是怎么样的呢?也许平时我们实践的时候也会尝试着去写一个stack的实现玩玩。这里,我们就仔细的分析一下jdk里的详细实现。Stack如果我们去查j...
  • 遗传算法,vector

    2015-05-04 18:53:00
    小袋鼠你往哪儿跳--遗传算法 ...想了很久,应该用一个怎么样的例子带领大家走进遗传 算法的神奇世界呢?遗传算法的有趣应用很多,诸如寻路问题,8数码问题,囚犯困境,动作控制,找圆心问题(...
  • <div><p>请问能描述一下怎么样从FeatherNet的输出向量(长度1024的)计算出score吗?</p><p>该提问来源于开源项目:SoftwareGift/FeatherNets_Face-Anti-spoofing-Attack-Detection-...
  • vector中的capactiy 与size

    2009-09-02 17:47:00
    vector中的size表示什么?capacity有表示什么?有什么区别,他们是怎么增长的 size 其实表示的实际的数据的多少,而capacity表示的为了能够接收这些数据,... 但是他们是怎么样增加的呢?是capacity是在什么时候增

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 148
精华内容 59
关键字:

vector怎么样