即使没有传递指针,线程中的所有函数都可以访问动态分配的内存(堆),还是函数的本地函数？
即使没有传递指针，线程中的所有函数都可以访问动态分配的内存（堆）。这是因为线程共享内存空间，包括堆内存。在多线程环境中，所有线程都可以访问动态分配的内存，因此不需要传递指针。
线程中的所有函数都可以访问动态分配的内存（堆），这意味着在多线程环境中，所有线程都可以访问动态分配的内存。这是因为线程共享内存空间，包括堆内存。
堆内存是动态分配的内存，它在程序运行时分配和释放。堆内存的大小是动态的，可以根据程序的需要进行调整。堆内存的分配和释放是由程序员手动完成的。
堆内存的优势在于，它可以在运行时动态分配内存，因此可以适应不同大小的数据结构。堆内存的缺点是，它的分配和释放需要程序员手动完成，这可能会导致内存泄漏和内存溢出等问题。
堆内存的应用场景包括：
- 动态分配内存：当程序需要动态分配内存时，可以使用堆内存。
- 存储大量数据：当程序需要存储大量数据时，可以使用堆内存。
- 适应不同大小的数据结构：当程序需要适应不同大小的数据结构时，可以使用堆内存。
推荐的腾讯云相关产品：
- 云服务器：腾讯云提供了云服务器，可以满足用户的计算需求。
- 对象存储：腾讯云提供了对象存储服务，可以存储和管理用户的数据。
- 数据库：腾讯云提供了数据库服务，可以存储和管理用户的数据。
相关产品介绍链接地址：
相关·内容
2回答
C++线程间的内存共享
、、、、
我对C++中的线程很陌生，我正在努力弄清楚内存是如何在线程之间共享/不共享的。我使用的是std::thread和C++11，根据我在其他问题上所读到的，堆栈内存只有一个线程拥有，堆内存在线程之间共享。因此，根据我对堆栈和堆的理解，下面的内容应该是正确的：
#include <thread>
using namespace std;
class Obj {
public:
int x;
Obj(){x = 0;}
};
int main() {
Obj stackObj;
Obj *heapObj = new Obj();
thread t
浏览 3提问于2012-07-05得票数 23
回答已采纳
计算机系统:程序员的观点说：
12.4.2在线程C程序中将变量映射到内存变量，根据它们的存储类将变量映射到虚拟内存:全局变量。全局变量是在函数之外声明的任何变量。在运行时，虚拟内存的读/写区域包含任何线程都可以引用的每个全局变量的一个实例。例如，第5行中声明的全局ptr变量在虚拟内存的读/写区域中有一个运行时实例。当只有一个变量的实例时，我们将简单地使用变量名表示实例--在本例中是ptr。局部自动变量局部变量是在没有静态属性的函数中声明的变量。在运行时，每个线程的堆栈包含它自己的任何本地自动变量的实例。即使多个线程执行相同的线程例程，也是如此。例如，局部变量tid有一个实例，它驻留在主线程的堆
浏览 0提问于2020-11-28得票数 2
据我所知，malloc()(或任何堆分配函数)和free()必须配对。我以为多线程程序也是一样的。但是看起来我不应该free()一个在另一个线程上分配的堆变量。
当我运行下面的代码时(在wsl ubuntu环境中)，
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void* thread_main(void* arg) {
int i = 0;
for (; i < *((int*)arg); i++) {
浏览 0提问于2019-06-09得票数 0
回答已采纳
不同线程的堆栈是different.but，那么堆呢？如果不同线程的堆是不同的，那么它们如何共享对象？
浏览 0提问于2013-11-20得票数 4
2回答
我想知道我的数组存储在哪里，如果它有可变大小，如下面的代码，这是因为在我的教科书中，它说在运行时内存分配给堆是为了我的理解，但是它似乎实际上分配给堆栈，有人可以澄清堆栈和堆内存分配实际上是如何工作的。
#include<iostream>
using namespace std;
int main(){
int Array_size;
cin >> Array_size;
int array[Array_size];
return 0;
}
浏览 1提问于2019-02-03得票数 1
回答已采纳
我知道使用new分配的内存在堆中获得空间，因此我们需要在程序结束之前删除它，以避免内存泄漏。
让我们看看这个节目..。
Case 1:
char *MyData = new char[20];
_tcscpy(MyData,"Value");
.
.
.
delete[] MyData; MyData = NULL;
Case 2:
char *MyData = new char[20];
MyData = "Value";
.
.
.
delete[] MyData; MyData = NULL;
在案例2中，它不是向堆内存分配值，而是指向字符串文本。
浏览 9提问于2010-06-07得票数 1
回答已采纳
4回答
嗨，我对堆变量没有什么疑问.
我想编写一个如下所示的函数：->
struct test
{
int x;
int y;
};
test* fun()
{
test *ptr = new test;
return ptr;
}
我怀疑会返回堆变量，一旦它超出作用域，它就会失去它的值。
肯定存在内存泄漏。(因为堆变量没有被删除)。
那么，我如何设计这样的功能。
浏览 4提问于2013-01-27得票数 3
回答已采纳
8回答
一位有经验的C++用户告诉我，我应该努力使用堆变量，即：
A* obj = new A("A");
与此相对的是：
A obj("A");
除了使用指针很好和灵活之外，他还说最好把东西放在堆上而不是堆上(堆栈比堆小？)。是真的吗？如果是这样，为什么？
注:我知道生命周期的问题。让我们假设我已经适当地管理了这些变量的生命周期。(即，唯一值得关注的标准是堆存储与堆栈存储，而不涉及生命周期)
浏览 1提问于2012-06-02得票数 19
回答已采纳
2回答
我如何定义在我的类的析构函数中是否需要为指针调用"delete“？指针(成员变量)可以指向堆中分配的缓冲区或不在堆中分配的缓冲区(它可以是只读内存中的文字，也可以是放在堆栈中的文字)。解决这个问题的最好方法是什么？我是否只需要为它使用另一个标志，或者可能是获取堆边界的地址并检查它们之间是否存在缓冲区地址？还是有更理性的方式？
浏览 0提问于2013-04-30得票数 1
回答已采纳
我对以下新变量"num2“是否也在堆内存中感到困惑，因为我将" num1”值分配给它，而num1被分配给堆内存。
int main()
{
int *num1 = malloc(sizeof(int)); /* assign num1 to heap memory */
*num1 = 7;
int num2 = *num1; /* assign num1's value to num2, is num2 also on heap?*/
return 0;
}
浏览 11提问于2014-04-09得票数 2
回答已采纳
很多人似乎都认为动态分配的指针或结构存储在堆中以及它所指向的变量中。
typedef struct {
char** data;
int size;
}a_struct;
void aFunction() {
int* p = (int*) calloc(rows, sizeof(int));
printf("p: %11d\n", &p);
printf("p_0: %11d\n", &p[0]);
printf("p_1: %11d\n", &p[1]);
int a = 2;
浏览 0提问于2019-12-12得票数 0
回答已采纳
4回答
#include <SDL/SDL.h>
int main (void)
{
SDL_Surface* screen;
screen=SDL_SetVideoMode(640, 480, 32, SDL_SWSURFACE);
return 0;
}
screen是指向绘图后台缓冲区的指针，这需要相当多的内存。
我的问题是，像这样定义的屏幕是基于堆栈的内存，因为堆内存将使用malloc。因为堆栈内存是有限的，所以上面的代码是不好的，因为它占用了大量有限的堆栈内存，它应该使用堆内存。但这段代码来自开源代码，我假设他们知道自己在做什么。
浏览 1提问于2013-07-20得票数 3
3回答
我是C++的初级程序员，有一个关于变量的问题。
例如，如果我有这样的方法：
int wow()
{
int x = 99;
return 0;
}
当此方法退出(返回0)时，它是否破坏了变量x？
这个变量是存储在堆栈中还是堆中？
例如，我知道您可以执行int *x = new (99)，然后它就会在堆中。
但是没有*，它在堆栈里面吗？
在上面的方法中，当它退出时，x被破坏了吗？
浏览 2提问于2014-04-19得票数 0
回答已采纳
5回答
1.这两个维度是如何存储在内存中的，它们是连续的吗？(我的意思是intM，不是动态分配，我认为intM发生在堆栈区域，所以是连续的，不是吗？)
2. malloc分配的区域是否必须是连续的？
3.如果不需要动态分配内存空间，应该在哪里使用？堆栈或堆。例如，我想要一个字符数组来存储10000个字符，那么我应该使用：
char a[10000];
或
char *a = calloc(sizeof(char),10000);
“函数调用栈”是否与变量栈在同一区域？？在同一堆栈中还是不同？
浏览 3提问于2013-02-23得票数 3
回答已采纳
3回答
我理解这个非常相似的问题的答案：
但我想确认：
下面是一个非常简单的程序：
void update_p(double * p, int size){
//do something to the values refered to by p
}
void test_alloc(int size){
double p[size];
unsigned int i;
for(i=0;i<size;i++)p[i]=(double)i;
update(&p,size);
for(i=0;i<size;i++)printf("%
浏览 5提问于2013-12-13得票数 1
回答已采纳
如果STL map是在函数中本地声明的，那么在函数退出之前是否需要清除映射？如果不清除，是否会导致内存泄漏？
浏览 1提问于2015-03-27得票数 1
回答已采纳
我的讲师说我们不需要删除在堆中创建的单例对象，因为当超出作用域时，它的内存会被释放并自动删除。
是不是因为编译器对待静态对象的方式不同，所以我们不需要担心从堆中删除这个对象？
在下面的代码中，我认为是指针超出了main中的作用域，而不是堆中的对象本身，但在某个时刻，如果确实为该对象释放了内存，则应该调用对象的析构函数？
我还尝试在main中添加成员函数DeleteObject，但我看不到堆中对象的析构函数正在被调用。
但是仍然看不到析构函数在屏幕上显示消息。
#include <iostream>
using namespace std;
class Singleton {
pu
浏览 0提问于2019-02-08得票数 0
2回答
堆栈与堆的澄清
、、
我读过堆栈用于管理函数调用，其中作为堆用于存储正在分配的对象。据我所知，非原始类型的对象将存储在堆中。在堆栈和堆的情况下，我对以下用法感到困惑：
1)原始数据类型、宏(#define)、静态对象、const和extern在哪里？
2)堆栈管理函数调用，但我想知道哪些与函数相关的信息正在推送到堆栈中？
3)我在某个地方看到与函数相关的本地对象存储在Stack中。那么，如果在函数内部进行对象的任何分配，则使用堆栈还是堆？如果在函数中声明了任何原始类型的对象，那么这些对象存储在哪里？
斯里。
浏览 7提问于2015-12-18得票数 2
6回答
我有一个包含指针的结构：
struct foo
{
char* f;
int* d;
wchar* m;
}
我有一个指向这些结构的共享指针的向量：
vector<shared_ptr<foo>> vec;
vec在堆栈上分配。当它在方法末尾传递到作用域之外时，它的析构函数将被调用。(对吧？)这将依次调用向量中每个元素的析构函数。(对吧？)调用delete foo是只删除诸如foo.f之类的指针，还是从堆中实际释放内存？
浏览 1提问于2010-06-09得票数 6
回答已采纳
7回答
在堆栈/堆上创建对象？
、、、
下面的代码在堆栈上创建一个对象：
Object o;
在堆上创建对象时，我们可以使用：
Object* o;
o = new Object();
而不是：
Object* o = new Object();
当我们将堆对象创建分成两行并在第二行(o = new object())调用构造函数时，这是否意味着在第一行(Object* o)中指针是在堆栈上创建的？所以Object o将对象放在堆栈上，而Object* o将指向未来对象的指针放在堆栈上？
我的第二个问题涉及到这两行代码是否在类的外部调用。我最近读到()，全局变量不包含在堆栈/堆中，但实际上是内存的另一部分？如果是这样，Object
浏览 2提问于2012-04-15得票数 64
回答已采纳
我是计算机科学的新手，我想知道一个对象是否被删除，如果我堆，分配它，然后为e。把它放在一个指针向量中，然后删除这个向量。堆对象会消失吗？这里是我的意思的一个例子。
int main()
{
Type* someHeapObject = new Type();
vector<Type*> someVector(0);
someVector.push_back(someHeapObject);
}
所以这里的主要部分是:我可以用delete someVector[0]删除堆对象吗，然后我就不必再像这样删除它了：delete someHeapObject
浏览 7提问于2022-08-20得票数 1
回答已采纳
4回答
假设您有一个使用C++动态链接库的VB6应用程序。它们共享相同的内存(你可以在另一个中使用指针)。使用Public Declare Function ... Lib ...在VB6应用程序中声明动态链接库
那么，这如何符合“堆栈从内存的一端增长，堆从另一端增长”的哲学呢？DLL的堆栈在哪里？应用程序启动时是否分配了全局DLL变量？如果是这样，为什么当我尝试从DLL运行函数时，它只给我一个错误？
浏览 0提问于2011-08-17得票数 3
回答已采纳
我不能在设备上分配的主机上释放内存，也不能在我在主机上分配的设备上释放内存。我使用的是VS2012和Nsight的数据自动化系统5.5。是因为主机上的堆没有传输到设备上的堆，或者相反，所以主机和设备之间的动态分配是未知的吗？
如果这是在文档中，很难找到。还需要注意的是，直到我在CUDA调试和启用内存检查器的情况下运行程序，才会引发错误。这个问题并没有在CUDA调试之外造成崩溃，但是如果我没有追溯性地检查内存问题，那么以后就会产生问题。如果有一种方便的方法把堆/堆栈从一个主机复制到另一个设备，那就太棒了.希望和梦想。
下面是我问题的一个例子：
__global__ void kernel(cha
浏览 5提问于2013-08-23得票数 2
回答已采纳
3回答
C++中的线程本地数据
、、、
我最近一直在试验线程本地存储。我有可以工作的代码，一切似乎都很好，但是当我使用valgrind运行我的程序时，它看起来有一些问题。
我的问题是，如果我将内存分配给静态线程本地存储，它会在线程退出时被删除吗？
下面是我的代码：
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <pthread.h>
void *test (void *arg)
{
static __thread int val = 0;
static __thread c
浏览 0提问于2013-11-07得票数 6
typedef struct animal
{
char* name;
struct animal* next;
}
animal;
animal *create_list(char* name);
int main(void)
{
animal *head = create_list("giraffe");
printf("%s\n", head->name);
free(head);
}
// Initialise list
animal *create_list(char* name)
{
a
浏览 1提问于2022-03-14得票数 1
3回答
堆栈中的变量是否“静态分配”？
、、、、
我在阅读时看到了这样的情况：“本文假设您至少已经基本了解和理解GNU系统中的内存映射是如何工作的，特别是堆栈中静态分配的内存和堆中动态分配的内存之间的区别。”
这让我感到困惑，因为我认为堆栈和堆是动态分配的，这意味着只有在必要时才分配，而声明为函数内部的“静态”的全局变量和变量是静态分配的，这意味着总是分配。
例如，如果我有
void f() {
int x = 1;
...
}
只有在调用函数f()时，值1才会被放到堆栈上，堆栈指针才会增加。同样，如果我有
void f() {
int x = malloc(1 * sizeof(int));
...
}
只有
浏览 4提问于2015-10-10得票数 3
回答已采纳
2回答
因此，我有一个向量向量，它是堆分配的：
std::vector<std::vector<int>>* matrix = new std::vector<std::vector<int>>();
在将大量数据放入matrix之后。删除这个对象的正确方法是什么？
delete matrix是否释放所有内部向量？
浏览 4提问于2016-07-17得票数 2
回答已采纳
4回答
我有几个与此相关的问题：
NSArray数组；在本地作用域中将有一个在堆栈上“分配”的对象。NSArray *数组；指示由大量内存支持的对象，通常是从堆中分配的。
您如何知道什么时候在堆栈和堆上分配了一些东西？堆栈中是否都有局部变量，堆中是否都有指针？
因为您没有取消引用指向对象的指针，而指向对象的指针在方法实现本身中是至关重要的。你说..。
哈
浏览 5提问于2010-01-13得票数 2
回答已采纳
在c++ Qt中，我喜欢用管理堆内存，但是可以/应该使用它们来管理中的数据。
例如，可以有一个QStrings QList<QSharedPointer<QString> > queue的列表。
问题是，在实现QSharedAbstractItemModel (如QAbstractListModel )时，需要处理原始指针。例如，方法返回一个，它在构造函数中接受一个空指针，指向堆中的其中一个QStrings。一旦创建了该对象，就可以使用堆内存(托管内存和非托管内存)。
因此，如果我将选定的项存储在指针的某个位置，然后清除模型，则指向该指针的数据将被删除。
那么如何处理要
浏览 2提问于2015-01-21得票数 2
回答已采纳
我正在考虑创建一个全局静态结构，如下所示：
typedef struct {
Thing things[1024];
} MyBigStruct;
static MyBigStruct s;
为什么不在“静态-全局区域”中放置大型结构化对象呢？这个地区有限制吗？我是否应该在堆中使用malloc声明这一点？
请不要参考针对全局变量的编码实践，而只是在技术方面。
浏览 1提问于2019-04-26得票数 4
回答已采纳
2回答
我做了一双这样的
typedef std::pair<int, Dish> OrderPair;
当迪什是物体的时候。我得到了一个OrderPair向量：
std::vector<OrderPair> orderList;
假设我想从向量中删除一对，当我不想从内存中删除碟子时，擦除函数是否就足够了？我认为答案是肯定的，因为创建一对不存在于堆中，因此我不需要释放任何内存。如果我错了请告诉我。
浏览 0提问于2018-11-05得票数 3
回答已采纳
1回答
C++中堆的损坏
、、
我是一个初学C++的程序员。最近，我开始使用C++进行图像处理。我正在尝试定义和使用以下函数：
Matrix MVE(Matrix R, double tolerance)
{
int n = R.Y();
Matrix P(n,4);
for (int i = 0; i < n; ++i)
{
P[i][0] = R[i][0];
P[i][1] = R[i][1];
P[i][2] = R[i][2];
P[i][3] = 1.0;
}
Ma
浏览 2提问于2013-09-24得票数 1
据我所知，std:: thread ::swap交换了两个线程的线程I。它不会改变线程的本地存储，也不会以任何方式影响任何一个线程的执行。它背后的目的是什么？如何/在哪里/为什么使用它？
浏览 4提问于2020-02-21得票数 2
2回答
C/C++中的并发编程、栈和堆
、、、、
我很抱歉，如果这感觉像是重复了一些老问题，我已经经历了几个关于堆栈溢出的问题，这是tanenbaum的“现代操作系统手册”，但我仍然不得不澄清我对此的疑虑。
首先，为了更好地理解这个结构，我很感激我应该详细阅读的任何书籍/资源。我无法理解这些概念是否是操作系统书籍、编程语言或体系结构书籍中通常解释的概念。
在我提出问题之前，我将根据有关堆栈/堆的阅读资料列出我的发现。
堆
包含所有实例变量，动态分配(new/malloc)和全局变量
不再使用数据结构堆，而是使用更复杂的结构。
通过内存位置进行访问，负责分配内存的单个进程
碎片整理和内存分配由操作系统完成(如果是或否，请回答我关
浏览 3提问于2013-01-24得票数 7
回答已采纳
5回答
我正在寻找编写一个自我碎片整理的内存管理器，其中一个简单的增量堆分配器与一个简单的压缩碎片整理程序结合使用。
粗略的方案是从最低的内存地址开始向上分配数据块，并从最高的内存地址开始向下分配记账信息。
内存管理器将传递回智能指针-boost的intrusive_ptr似乎对记账结构来说是最明显的，然后这些结构本身将指向实际的内存块，从而提供一定程度的间接性，以便这些块可以轻松地移动。
碎片整理程序将从“生成”书签开始压缩堆，以加快进程，并且一次只整理固定数量的内存。指向块本身的原始指针将一直有效，直到下一次碎片整理通过，因此可以自由传递，直到此时提高性能。
这方面的具体应用是控制台游戏编程，因此
浏览 1提问于2009-09-20得票数 9
回答已采纳
我想知道是否有可能利用scala-native来执行大型内存作业。
例如，假设您有一个需要150‘t的spark作业，因此您必须在spark集群中运行5x30’t的执行程序，因为JVM垃圾收集器不会赶上更大的堆。
想象一下，99%被处理的数据都是集合中的Strings。
你认为scala-native在这方面会有帮助吗？我是说，作为Spark的替代品？
它是如何对待String的？因为jvm把它当做类，所以它也有这样的开销吗？
在JVM中，经典的30 GC内存(“堆”)GC限制是多少？我最终也会有30 up这样的限制吗？
或者这通常是个坏主意？使用scala-native进行内存中的数据处理。
浏览 12提问于2016-09-05得票数 5
3回答
对于堆栈和堆是如何安排在多线程进程中的，我有点困惑：
每个线程都有自己的私有堆栈。
所有线程共享堆。
当程序动态创建线程(Java中的ex: new ())时，对象将在堆上分配。
那么堆是否包含线程对象的内存，这意味着堆是否包含堆栈(属于线程)？
浏览 4提问于2010-09-05得票数 3
回答已采纳
我想知道在动态创建2d数组时分配了多少大小 假设我在c++中动态创建一个一维数组，结果如下所示 int* p = new int[10]; 这意味着堆内存中有40字节，栈内存中有8字节(根据我的编译器)，但我很困惑，如果我将2d数组设为(对于10*10 2d数组)，将分配多少内存 int** p = new int*[10];
for(int i = 0; i < 10; i++) {
p[i] = new int[10];
} 我的堆栈和堆中将分配多少内存，它在堆栈中是80字节，在堆中是400字节或其他什么
浏览 9提问于2019-01-22得票数 4
回答已采纳
3回答
我在努力减少内存泄漏。
显然，最好的解决方案是从一开始就不泄漏内存。
但在我的例子中，我需要查看现有的指针，并确定其中是否有一个是动态分配的，需要删除。
给定特定地址/指针，C++是否提供了一种确定给定地址是否指向堆的方法？
奖金：
C++提供了一种方法来确定是否需要用delete[]删除给定的堆地址，而不是普通的delete。
浏览 12提问于2021-01-15得票数 0
回答已采纳
当从JNI线程调用fork()时，Java堆会发生什么。Java堆是复制的吗？
本地内存段、JNI内存、类内存、线程内存和线程本地堆(TLH)会发生什么情况？
浏览 1提问于2018-08-17得票数 1
我正在编写一个自定义编辑控件(C++/Win32 32)，并且已经在运行中获得了基本功能。
I使用c样式缓冲区在编辑控件中存储可见文本的内容。现在，我想知道是否应该使用malloc/free组合体从堆中分配内存，还是应该继续使用new/delete对？前几天遇到了一个问题。我创建了一个动态的
已分配的c -style字符串类成员(char* szClassName)。然后我
在初始化程序列表中将其初始化为
szClassName("name of class")。
当我在析构函数中使用'delete szClassName‘时，会导致一些内存分配错误。你们能告诉我问题吗
浏览 0提问于2011-11-11得票数 1
回答已采纳
让我们考虑一下这个例子。
class StaticlyManagedObject
{
//some class members....
}
class DynamiclyManagedObject
{
StaticlyManagedObject _staticlyManagedObject; //is this still allocated at the stack?
}
class Foo
{
DynamiclyManagedObject * _dynamiclyManagedObject; //will be allocated in the heap.
Foo(
浏览 4提问于2016-08-19得票数 2
回答已采纳
2回答
我已经构建了一个由python层和C++层组成的库。在C++层，我有一大块内存需要保存在堆中，因此该块必须在编译时动态分配。
我想要做的是使这块内存在python端可配置。有没有办法从python中动态分配内存空间，并将指针传递到C++层？
谢谢
浏览 0提问于2020-07-10得票数 2
1回答
我知道使用完free()函数来销毁指针是很好的习惯，但是如果从函数返回指针会发生什么呢？我想它没有发送副本，因为没有机会摧毁它。指针“切换”作用域到调用函数吗？
示例(无用代码，注意事项)：
int* getOne(){
int a = 1, *pA;
pA = &a;
return pA; //what happens to this
}
int main(){
printf("%i", getOne()); //uses data from the same addresses allocated to pA above?
浏览 5提问于2015-06-05得票数 2
回答已采纳
2回答
我有一个有网格的游戏，它是一个二维数组。这个数组填充了一个信息结构。
struct GridCell
{
uint mCellID;
Vector2 mPosition;
uint mLevel;
int mCellType;
};
class Grid
{
public:
Grid();
~Grid()
protected:
// Heap
GridCell[][] mGridCells;
// Dynamic
GridCell*[][] mGridCells;
};
记住，内存中一次可以有多个网格，这些网
浏览 0提问于2012-12-20得票数 2
回答已采纳
8回答
我编写了一个简单的库文件，它具有从任意大小的文件中读取行的函数。函数是通过传入堆栈分配的缓冲区和大小来调用的，但是如果行太大，则初始化一个特殊的堆分配缓冲区，并用于传回更大的行。
这个堆分配的缓冲区是函数作用域并声明为静态的，当然在开始时初始化为NULL。我在函数开始时编写了一些检查，以检查堆缓冲区是否为非空；如果是这样的话，那么前面的行读太长了。自然，我释放堆缓冲区并将其设置为NULL，认为下一次读取可能只需要填充堆栈分配的缓冲区(即使在我们的应用程序中，也很难看到超过1MB的行)。
我仔细阅读了代码并对其进行了相当彻底的测试，并运行了一些测试。我相当有信心保持以下不变：
如果只需要堆栈
浏览 0提问于2010-01-25得票数 2
回答已采纳
2回答
在下面的C++代码中，s被分配到哪里？它使用堆、数据、bss还是某种组合？我使用的是Linux/x86平台，以防有什么不同。有没有办法让g++编译器给我显示布局？
#include <string>
#include <iostream>
using namespace std;
string s;
int main()
{
s = "test";
cout << s;
}
浏览 2提问于2010-12-09得票数 3
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
