指向同一内存的两个指针和realloc失败
指向同一内存的两个指针是指两个指针变量同时指向同一个内存地址。realloc是C语言中用于重新分配内存大小的函数，它可以用来扩大或缩小已分配内存的大小。当realloc函数调用失败时，会返回NULL指针。
在指向同一内存的两个指针的情况下，如果其中一个指针通过realloc函数重新分配内存失败（即返回NULL），那么另一个指针也会受到影响。因为realloc函数在重新分配内存时，会尝试将原有内存块的内容复制到新的内存块中，然后释放原有内存块。如果realloc失败，原有内存块将不会被释放，而新的内存块也不会被创建，这将导致两个指针都指向一个无效的内存地址。
这种情况下，使用这两个指针可能会导致内存访问错误，例如访问无效的内存地址或者访问已释放的内存。这可能会导致程序崩溃、数据损坏或其他不可预测的行为。
为了避免这种情况，我们应该在使用realloc函数重新分配内存后，检查返回的指针是否为NULL。如果为NULL，则表示realloc失败，我们应该谨慎处理，避免使用指向原有内存块的指针。
在云计算领域，这个问题与云计算的概念、分类、优势、应用场景、腾讯云相关产品和产品介绍链接地址没有直接关联。但是作为一个云计算领域的专家和开发工程师，我们应该具备解决这类问题的能力，并且了解内存管理的基本原理和常见问题。
相关·内容
4回答
在这个例子中：为什么有两个指针:数字和more_numbers？我可以用：
numbers = (int*) realloc (numbers, count * sizeof(int));
if (numbers!=NULL) {
numbers[count-1]=input;
}
else {
free (numbers);
puts ("Error (re)allocating memory");
exit (1);
}
浏览 0提问于2014-03-21得票数 1
回答已采纳
我编写了一个函数来读取带有fget的字符串，在需要时使用realloc()来使缓冲区增长：
char * read_string(char * message){
printf("%s", message);
size_t buffsize = MIN_BUFFER;
char *buffer = malloc(buffsize);
if (buffer == NULL) return NULL;
char *p;
for(p = buffer ; (*p = getchar()) != '\n' &&am
浏览 2提问于2012-12-09得票数 2
回答已采纳
1回答
我是个指针和realloc新手。我知道哪里出了问题，但我不知道如何解决它。
我创建了一个带有指针数组的结构：
struct DB_SLOT
{
MYSQL *MYSQL_Connection[10];
char *DB_NAME_Connection[10];
};
struct DB_SLOT DB_Conn_SLOT;
我在一个循环中使用realloc分配内存(这就是它出错的地方)，我在屏幕上打印指针2的地址。
如果我随后尝试realloc相同数量的内存(只是为了测试目的)。它为glibc提供了无效的指针。在realloc之前，我再次打印指针2的地址，但它并不相同。
代码
浏览 1提问于2015-07-16得票数 0
1回答
在我的函数中有两个"free(t)“。当我调用函数并转到第一个free(t)时，一切正常，然后函数self调用自己，然后，在代码底部的free(t)中，发生分段失败。为什么会发生这种情况？为什么第一个"free(t)“没有导致分割失败，而第二个结果呢？谢谢
char c[50];
int b, j=0, d=0, e=0;
PLAYER *pt1;
MANAGER *pt2;
t=malloc(24*sizeof(TEAM));
tfile=fopen("team.txt", "r");
while(fscanf(tfile, "%d
浏览 0提问于2019-01-25得票数 0
7回答
int *f, *l;
int main(){
int *a;
a = calloc(1, sizeof(int));
f = l = a;
put(&a, 1);
put(&a, 3);
put(&a, 2);
_getch();
return 0;
}
void put(int **a, int d){
printf("--%d--", sizeof(*a)); //always == 4
void *tmp = (int *)realloc(*a,
浏览 0提问于2011-11-02得票数 1
见以下功能：
int go(void) {
int *p, *q;
p = calloc(10,sizeof(int));
q = realloc(p, 20 * sizeof(int));
<<X>>
}
假设两个内存分配函数调用都是成功的，那么在点标记<<X>>上下列哪条语句是正确的。
P和q的值是相同的。
P指向10个整数，每个整数的值为0。
Q指向至少80字节的内存。
这个问题在我的C试题中。除了(2)，这显然是正确的。我对(1)和(3)很困惑。有人能解释一下吗？
浏览 8提问于2011-11-18得票数 2
回答已采纳
如果realloc失败并返回NULL，是前一个缓冲区已释放还是保持完好？我没有在手册页中找到这条特定的信息，我不确定该怎么做。如果内存被释放，那么双重释放可能会有风险。如果不是，那么就会发生泄漏。
浏览 9提问于2009-10-22得票数 30
我对在C中使用动态内存还是个新手，我想知道使用realloc()分配给不同的指针和使用realloc()分配相同的指针是否有什么区别。例如： int *ptr = calloc(10,sizeof(int))
ptr=(int*)realloc(ptr,20); 和 *ptr3;
int *ptr = calloc(10,sizeof(int))
ptr3=(int*)realloc(ptr,20); 我已经执行了这两个代码，并且我看不到这两个代码之间的真正区别(也没有看到操作符的值和内存分配之间的区别)。谢谢。
浏览 15提问于2021-06-18得票数 0
我一直在读一本关于C++内存管理的书，它有很多细节，并且很好地解释了一些事情。无论如何，我有一个我一直在做的程序，它必须处理一些非常大的向量或数组。不过我很困惑。我决定只是以防万一试着分配记忆。
我的问题是，如果我尝试malloc()一定数量的数据，然后出了问题。如果我想再次预置malloc()并分配更少的数据，我是使用realloc()还是再次使用malloc()？我认为这听起来是一个愚蠢的问题，然而，因为第一次malloc()会失败，难道它不是完全被错误的……?？?意味着你应该还能在上面使用malloc()吗？
所以..。我应该使用哪一种，还是根本不使用以下任何一种？
BYTE *allo
浏览 9提问于2017-10-28得票数 0
回答已采纳
char *oldPointer, *newPointer;
oldPointer = (char*)malloc(1000);
newPointer = (char*)realloc(oldPointer, 2000)
现在可以使用oldPointer了吗？
现在会发生什么？
oldPointer = newPointer;
如果free(newPointer)
浏览 0提问于2019-03-30得票数 3
回答已采纳
我需要创建一个动态数组，而不是由一个函数填充。我无法事先知道这个数组有多大。所以我做了以下几件事：
TAB_TYPE *column_types = malloc(100*sizeof(TAB_TYPE));
hExtract = make_table_definition(jsstr, tokens, column_types);
我随机决定分配100个元素。在函数内部，我用以下方法调整了它的大小：
realloc(column_types, tokens[0].size /2 * sizeof(TAB_TYPE)))
上面的行在使用GCC编译时产生了以下错误：
error: ignorin
浏览 3提问于2014-12-11得票数 1
在这段代码中释放内存的正确方法是什么？
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main( void ){
char *string1, *string2;
string1 = (char*) malloc(16);
strcpy(string1, "0123456789AB");
string2 = realloc(string1, 8);
printf("string1 Valor: %p [%s
浏览 4提问于2016-05-03得票数 12
回答已采纳
可能重复：
假设我有一系列的指针
char **pointers_to_pChar = 0;
pointers_to_pChar = (char **)malloc(sizeof(char *) * SIZE);
for (i = 0; i < SIZE; ++i)
{
pointers_to_pChar[i] = malloc(sizeof(char) * 100));
}
//some stuff...
//time to realloc
pointers_to_pChar = realloc(pointers_to_pChar, sizeof(char *)
浏览 3提问于2012-09-13得票数 0
回答已采纳
1回答
我正在尝试使用malloc和realloc来保存结构数组。数组应该动态增长，每次大小应该增加10个结构元素。
结构：
typedef struct
{
unsigned char foreign_word_[100] = {0};
unsigned char native_word_[100] = {0};
} VocabularyCouple;
在我的main中，我使用malloc初始化数组：
VocabularyCouple* VocStruct = (VocabularyCouple*)malloc(sizeof(*VocStruct) * 10);
增加struct-a
浏览 8提问于2019-11-11得票数 2
2回答
当我在我的项目中使用C函数realloc(p,size)时，代码在模拟器和iPhone 5上都运行良好。
但是，当代码运行在iPhone 6+上时，会发生一些奇怪的事情。a指向的内容被更改了！更糟糕的是，每次函数运行时，输出都是不同的！
下面是测试代码：
#define LENGTH (16)
- (void)viewDidLoad {
[super viewDidLoad];
char* a = (char*)malloc(LENGTH+1);
a[0] = 33;
a[1] = -14;
a[2] = 76;
a[3]
浏览 2提问于2015-05-15得票数 1
回答已采纳
我搞错了，上面写着
调试断言失败，检测到热损坏
就像我的程序里一切都很好，但是我得到了那个错误。这里的内存泄漏在哪里？我必须释放内存，因为我的函数需要返回指针。
我的代码：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int *dynamic_reader(unsigned int n) {
/*making new array and checking if allocation succeeded*/
int *mem;
mem = malloc
浏览 0提问于2018-02-21得票数 0
回答已采纳
1回答
我正在编写一个并行程序，在这个程序中，我必须重新分配一个由其他线程主动写入的内存块。这样做的自然方法是使用realloc，但是当在并行写入的块上调用realloc时，有两种可能的结果：
realloc能够扩展分配。occur.realloc必须创建一个新分配，将旧分配的内容复制到新分配中，并释放原始分配。
第二种情况是有问题的，原因有二：
首先，因为初始分配中的字节可以在复制字节之后和realloc返回之前写入。在这种情况下，一旦释放旧分配，写就会丢失。
第二，因为realloc将在返回之前释放旧分配，因此并发访问该内存区域的其他线程将读取已释放的内存，这并不保证是安全的。
目前，我使用了一个
浏览 2提问于2020-06-22得票数 0
我编写了一个程序，它应该在文件中进行查找和替换，条件是新单词必须比旧单词长。我对它有很多问题，比如打印奇怪的字符，或者抛出内核，但是当我删除realloc语句时，问题似乎就消失了。我对这个功能不太熟悉，我犯了什么错误？
还有，我的自由在哪里呢？
void replace_word(const char *s, const char *old_word, const char *new_word){
char *buffer = malloc(BUFFER_SIZE);
char *init = buffer;
FILE *original_file;
FILE
浏览 3提问于2017-05-14得票数 1
回答已采纳
3回答
我正在编写一个程序，其中的输入将从stdin中获取。第一个输入将是一个整数，表示要从标准输入读取的字符串数。我只是将字符串逐个读取到动态分配的内存中，并在字符串结束时显示它。
但是当字符串大于分配的大小时，我会使用重新分配内存。但是，即使我使用memcpy，程序也可以工作。不使用memcpy是不是未定义的行为？但是示例没有使用memcpy。那么哪种方法才是正确的呢？下面显示的程序是正确的吗？
/* ss.c
* Gets number of input strings to be read from the stdin and displays them.
* Realloc dynami
浏览 0提问于2012-10-26得票数 3
回答已采纳
在这种情况下，房地产公司会失败吗？
int *a = NULL;
a = calloc(100, sizeof(*a));
printf("1.ptr: %d\n", a);
a = realloc(a, 50 * sizeof(*a));
printf("2.ptr: %d\n", a);
if(a == NULL){
printf("Is it possible?\n");
}
return (0);
}
在我的例子中，输出是：
1.ptr: 4072560
2.ptr: 4072560
所以“a”指的是同一句话。那么我应该强
浏览 0提问于2010-03-29得票数 9
回答已采纳
1回答
我在使用malloc和getchar从用户中读取类似的内容时遇到了一些问题。我得到了结果，然而，我得到内存泄漏使用valgrind。我对此一无所知，问过我的同学和导师，但似乎没有人知道原因。
char *ReadLineFile(FILE *infile){
int i=0;
char c;
char *newStringLine;
newStringLine = (char *) malloc(sizeof(char));
while( (c = fgetc(infile)) != '\n' ){
newStringLine[i+
浏览 1提问于2017-08-29得票数 1
回答已采纳
6回答
如果我有一个变量str，我想在堆中为它分配内存，我将使用malloc()如下：
char* str = (char*)malloc(sizeof("Hello"));
malloc()正在返回一个void*指针，这是我的内存所在的内存位置。所以现在，我可以给它一些数据
str = "Hello";
因此，内存位置现在已经满了，有6个字节。现在，我想增加它的大小，以包含字符串"Hello World"。所以，我使用realloc()。根据man的说法，void* realloc(void *ptr, size_t size)将：
The reall
浏览 10提问于2014-01-05得票数 0
回答已采纳
在我开始之前，我应该说，这与一个直接的问题无关，而是出于好奇心和我无法找到与我所追求的目标有关的东西。我现在正在教自己C，我有其他几种语言的经验，所以它没有什么新的，只是确切地说是如何执行某些事情。
我想在C中完成一个挑战，比如构建一个必要的堆栈，并为此选择使用一个结构：
#define INITIAL_STACK_SIZE 10
typedef struct Stack {
int max_size;
int cur_top;
int *elements;
} Stack;
我将元素保留为空点，以便在必要时展开元素，这使得构建堆栈的函数类似于：
Stack *Stack_mak
浏览 6提问于2014-03-19得票数 1
回答已采纳
4回答
如果我尝试使用realloc为指针分配比最初分配的更少的内存，那么冗余内存会被释放还是重新分配会导致内存泄漏？
我不知道如何测试它，sizeof似乎返回了相同的值，而不依赖于我做了多少次重新分配。
浏览 2提问于2013-12-17得票数 3
回答已采纳
3回答
利用我在这里学到的知识：，我编写了这个程序。
int data_length; // Keeps track of length of the dynamic array.
int n; // Keeps track of the number of elements in dynamic array.
void add(int x, int data[], int** test)
{
n++;
if (n > data_length)
{
data_length++;
*test = realloc(*test, data_
浏览 2提问于2012-12-06得票数 1
回答已采纳
1回答
我正在试图组装一个特定的结构，以便将信息传递给一个函数。此函数以地址和大小作为参数。此外，信息的结构是由技术文档给出的，但包含一个动态部分。动态部分由一个重复的结构组成。
因此，在结构中使用一个结构数组就会引起人们的注意。
一个最小的例子可能如下所示：
struct nodeConfig_s{
int pdoCount;
int somethingElse;
struct pdo_s{
int flags;
int dataLength;
int id;
} pdos[];
}
我确实理解pdos[]只是指向数组的第一个元素的指针。
但是我想要实现的是，
浏览 0提问于2015-04-07得票数 2
1回答
嗨，伙计们，我很抱歉打扰你们，但是我开始失控了..我最近又开始用C语言编程了，我遇到了某种我不能理解的bug。我的C程序是(应该是)一个简单的程序，所以它需要执行以下操作:从键盘读取未定义数量的自然元素，直到读取到0。之后，它必须计算所有元素的乘积，并在该结果的末尾计算0-s的数量。
int input(int* v) {
int n = 0;
do
{
n = n + 1;
浏览 3提问于2011-03-09得票数 1
回答已采纳
2回答
int *p=malloc(20);
现在堆将分配20个字节的内存。并将第一个字节的地址返回给指针p.(假设不返回空指针)。
现在我做这个，
int *q=realloc(p, 40);
现在他们有以下几种可能性：
1]。q=p
2]。q!=p
3]。q=NULL
忘记了第二和第三种可能性。
现在我写到：
free(p);
现在会发生什么？
最初的20个字节会变成空闲的，rest仍然是分配的，还是所有的40个字节都是空闲的还是其他什么的？
浏览 1提问于2016-10-16得票数 1
回答已采纳
int *ptr;
...
realloc(ptr,++count*sizeof(int));
or
ptr=realloc(ptr,++count*sizeof(int));
我注意到，如果我不止一次使用第一个选项，第一个内存地址( ptr指向的)的值就会变成未定义的值(尽管内存块中的所有其他值都很好，可以通过订阅ptr访问)。
但是，我假设所有realloc都是缩小或增加内存块的大小，而ptr仍然指向同一个内存块，并且它的值都不会改变。所以，如果我使用第一个选项，为什么内存块中的第一个地址最终会有一个意外的值，因为ptr仍然指向同一个地址吗？
EDIT:我确实记得把内存分配给p
浏览 1提问于2014-08-21得票数 1
回答已采纳
问题描述
我在学指点。我成功地编写了一个示例代码。但我不知道为什么它能正常工作。基本上，我试图在函数fillArray中填充一个数组。因为我需要修改指针而不是指针所指向的对象，所以我传递了一个双指针**ppArray。这就像在C++中传递对指针的引用。每当我想要添加一个新元素时，我都使用realloc来增加数组大小。
我在设置pArray to NULL的那一刻就迷失了方向。为什么*ppArray在我们将pArray设置为NULL之后仍然保存pArray的所有值。为什么free(pArray)会导致double free detected in tcache 2。我将pArray设置为空！我真
浏览 1提问于2021-08-12得票数 1
回答已采纳
2回答
下面的第一个if语句检查在向数组添加元素时，是否已达到缓冲区大小的末尾。如果有，它就会复制原来的大小。
while (token != NULL) {
tokens[position] = token;
position++;
if (position >= bufsize) {
bufsize += LSH_TOK_BUFSIZE;
tokens_backup = tokens;
tokens = realloc(tokens, bufsize * sizeof(char*));
if (!tokens) {
浏览 6提问于2021-10-05得票数 0
2回答
假设我宣布了一个array[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}。稍后，我希望它是array[8] = {2, 3, 4, 5, 6, 7, 8, 9}。
排除前两个元素。因此，它将从array[2]开始。将array分配给array[2]。
我试过：
int *array=(int*)malloc(10*sizeof(int));
...//do stuffs
array=(int*)realloc(array[2],8*sizeof(int));
它没有起作用。既不使用&array[2], *array[2]，也不创建辅助数组，将数组重新分配给A
浏览 4提问于2017-04-07得票数 4
回答已采纳
4回答
我正在尝试释放重新分配的内存，但我得到一个错误...
float * foo = NULL;
float * bar = NULL;
void update()
{
...
foo = (float *)malloc( a * 2 * sizeof(float));
...
bar = (float *)realloc( foo, a * 2 * sizeof(float));
...
free( foo );
...
// when i do
if(bar != NULL)
{
free(bar
浏览 0提问于2012-03-27得票数 8
回答已采纳
3回答
据我所知，分段错误是当您还没有正确分配内存，而双空闲是当您试图释放您已经释放的内存？
增加结构数组大小的正确方法是什么，以及实际需要释放哪些部分？
我有一个结构：
struct Data {
// Some variables
}
我正在用以下方法初始化这些结构的数组：
int curEntries = 100;
int counter = 0;
struct Data *entries = (struct Data *)malloc(curEntries * sizeof(struct Data));
当我将数据从bin文件读取到这个数组并填充每个结构时，程序就会工作到需要超过1
浏览 0提问于2017-08-21得票数 2
回答已采纳
2回答
动态分配字符串数组
、、、
我想动态分配字符串数组，但我不确定如何才能做到这一点。所以我想做一个结构，并动态地分配这个结构。所以我写了下面的代码，但是这段代码会导致断言失败。
#include <stdio.h>
#include <stdlib.h>
typedef struct {
char str1[20];
char str2[20];
} String;
int main(void)
{
String * list;
list = (String *)malloc(sizeof(String));
int i = 1;
for (;
浏览 1提问于2017-06-03得票数 0
3回答
我声明了一个n x n数组，如下所示：
int **matrix = malloc(n * sizeof *matrix);
for (i = 0; i < n; i++)
matrix[i] = malloc(n * sizeof **matrix);
在做一些测量的时候，我想要添加额外的行和列，比如在第二行和第二列之后。我想添加2.3行和列(在2.2，3.2，2.3，3.3之间)。所以我想从已经设置的n x n数组(用数字等设置)转到n+1 x n+1数组，额外的行和行在数组中间的某个地方，而不是在最后。
附注:如果你很好奇，我正在尝试实现分层聚集聚类算法，其中我必须用新合并
浏览 0提问于2014-06-07得票数 2
所以我的问题是，当我在数组的一个成员中分配一个字符串的内存时，它被破坏了，我不知道为什么。我的主线是
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define maxsize 512
#define charsize 100
typedef struct Books {
char* id;
char* title;
char* author;
char* pages;
char* year;
char* subject;
} book;
char*
浏览 5提问于2017-04-04得票数 1
6回答
当我尝试使用realloc为一个已经被free'd的指针分配内存时，我得到了一个分段错误。不过如果我使用malloc就不会遇到这个问题了。
根据我的理解，在变量被free'd后，它相当于一个NULL指针，那么为什么会出现这种意外的行为呢?我是不是遗漏了什么？
浏览 2提问于2012-07-12得票数 0
回答已采纳
2回答
我试图使用realloc在堆中扩展一个ints数组，但是当我使用自定义函数"ExpandArrayOfInts“时，程序就崩溃了，但是当我在main中编写扩展程序代码时，它的工作效果很好。
下面是这两种方法的代码(file: main.c)和#defines。
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
int ExpandArrayOfInts(int* arrayToExpand, int expandBy, int inArraySize, int* outArrayS
浏览 0提问于2011-03-20得票数 0
回答已采纳
1回答
我必须动态增加双数组的长度。我知道如何使用char数组，所以我尝试了如下：
int main() {
char * tmp = NULL;
for (int i = 1; i <= 4; i++) {
tmp = realloc(tmp, i * sizeof(char));
tmp[i] = 'i';
}
puts("char OK");
double * tmp1 = NULL;
for (int i = 1; i <= 4; i++) {
tmp1
浏览 1提问于2019-11-21得票数 0
回答已采纳
谁能总结一下realloc()的正确用法是什么
当realloc()出现故障时，您该怎么办？
到目前为止，我所看到的似乎是，如果realloc()失败，您必须free()旧指针。这是真的吗？
下面是一个示例：
1. char *ptr = malloc(sizeof(*ptr) * 50);
2. ...
3. char *new_ptr = realloc(ptr, sizeof(*new_ptr) * 60);
4. if (!new_ptr) {
5. free(ptr);
6. return NULL;
7. }
浏览 0提问于2010-07-26得票数 17
回答已采纳
5回答
我正在从KandR C编程书中做一个有趣的练习。该程序用于从用户输入的一组行中查找最长的行，然后打印它。
以下是我所写的(部分，部分是直接摘自这本书的)：-
#include <stdio.h>
#include <stdlib.h>
int MAXLINE = 10;
int INCREMENT = 10;
void copy(char longest[], char line[]){
int i=0;
while((longest[i] = line[i]) != '\0'){
++i;
}
}
in
浏览 3提问于2014-07-04得票数 9
回答已采纳
1回答
我用realloc函数尝试了一些东西，遇到了字符串问题：
char *s="hello";
s=realloc(s,size); // this return null
char *p;
p=malloc(5);
strcpy(p,"hello");
p=realloc(p,size) // this works fine
为什么第一次声明失败？
浏览 2提问于2021-11-30得票数 0
回答已采纳
3回答
我试图实现一个简单的函数，它可以连接传递给它的任意数量的字符串。我调用realloc失败了。是不是因为我传递给函数的字符串参数存储在数据段中，而realloc希望从堆中分配内存？这只是我的一个想法。我是个初学者，如果这看起来很愚蠢，请原谅。怎样才能让这个函数运行？
//Program to implement a function that can concatenate any number of argumnets
#include<stdio.h>
#include<stdarg.h>
#include<string.h>
#include<
浏览 0提问于2012-02-01得票数 1
回答已采纳
所以当我分配一些空间时，我面临一个问题，然后在递归函数中重新分配这个空间，然后尝试将这个空间从递归函数中释放出来。Free()不会继续任何错误，但是调试表明，在执行free()之后，我仍然有旧的内容。因此，我得到的错误有: 1. malloc：* error for对象0x100200868:释放对象的不正确校验和-对象可能是在被释放后修改的。或者2.malloc：*对象0x100200000:指针未被分配的错误是什么原因？
void printTrie(FILE *file, char *initialPath){
initPath = initialPath;
if(ro
浏览 5提问于2014-10-18得票数 0
回答已采纳
我正在尝试实现一个连接两个字符串的函数，但我始终得到相同的错误。当我在windows机器上编译相同的代码时，没有分配指针，是不是缺少了什么？下面的代码基本上就是我想要做的。主要：
int main() {
int length = 4096;
char *string = malloc(length * sizeof(char));
createString(string, length);
realloc(string, 30);
return 0;
}
createString：
void createString(char * string, int length) {
char
浏览 2提问于2018-10-04得票数 2
回答已采纳
1回答
我正在编写一个程序，在这个程序中，我需要完成的任务之一是将文本文件的每一行(其名称通过命令行提供)存储为一个单独的字符串，以供以后的操作。
我的节目有两个问题。
第一个问题是在数组中存储字符串的问题。当我用字符串分配数组的索引时，一切正常。但是，一旦我释放()字符串用于分配另一个字符串，这两个字符串就会被删除。
userText[numStrings - 1] = currentString;
/* Both userText at index and currentString hold the same value at this point */
free(currentString)
浏览 3提问于2017-06-02得票数 0
回答已采纳
3回答
注意，这个问题不是问realloc()是否使原始块中的指针无效，而是它是否使所有其他指针无效。
我对realloc()的本质有些困惑，特别是如果它移动了任何其他内存。
例如：
void* ptr1 = malloc(2);
void* ptr2 = malloc(2);
....
ptr1 = realloc(ptr1, 3);
在此之后，我能否保证ptr2指向与realloc()调用前相同的数据？
浏览 5提问于2015-06-22得票数 1
回答已采纳
3回答
我的C程序崩溃了，我太新了，搞不清楚。到目前为止，它非常简单，我想代码足以找出哪里出了问题。
我只是想逐行读取文件。一旦我的内存不足，我会将一个结构的内存加倍。如果这不是足够的信息，我将提供您需要的任何其他信息。
非常感谢你的帮助，因为我已经被困了好几个小时了。
/*
John Maynard
1000916794
7/15/2013
HW-06
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define N 100
struct course
{
char subj
浏览 2提问于2013-07-16得票数 0
回答已采纳
假设我有一个指向一个结构数组(在堆上)的指针p1，其中每个结构s1也有一个指向另一个结构s2 (在堆上)的指针。如果我在p1上调用realloc()来调整它的大小，那么由预先重新分配的数组的结构持有的旧内存是否会被释放(堆上的s2s )？
我非常确定这个问题的答案是否定的，因为文档中指出了if the area pointed to was moved, a free(ptr) is done，这意味着它只会释放一个级别的深度。对吗？如果是这样的话，最好的解决方案是手动malloc一个新的数组，迭代旧的数组，将值复制到新的更大的数组中，并在其中释放结构吗？
浏览 5提问于2016-08-30得票数 2
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
对象存储
实时音视频
即时通信 IM活动推荐
腾讯云开发者
