如何有效申请内存空间

[牛耳朵]

刚遇到一个问题：
把一段不确定长度的字符串，写到申请的内存空间里。
由于不确定长度，所以用malloc申请的时候，想做个判断，比如先申请1024，如果不够，则加倍申请，直到足够。

请问这段代码如何实现。

[沙漠里的海豚]

楼主你的这个思路本身有点矛盾。

假设你不知道字符串的长度，那么你怎么判断malloc出来的空间是不是足够呢？
有些情况下需要扩展malloc出来的内存，但前提也是知道需要申请的内存需要多少的。

比如说，我创建一个链表，大小为100，malloc出100个空间。然后往里面写数据，但是只写了
60个数据，就有40个空间是剩余的。这样以后需要写数据的时候如果数据大小小于40自然就不
需要重新malloc了，但是如果数据大于40的话你就可以用relloc重新扩容到200.

不知这样说是不是能明白

[阿呆_]

就你的实际例子，可以用_vscprintf先求得所需要buffer的长度，然后malloc这个长度的buffer再用_vsprintf输出

[牛耳朵]

谢谢楼上各位的回答，有时间的话可否看下我的代码。

我先研究下10楼的兄弟说的那个。

[沙漠里的海豚]

呵呵 先前没明白楼主的意思，用10楼说的办法应该是可行的

[牛耳朵]

[Quote=引用 10 楼 Idle_ 的回复:]
就你的实际例子，可以用_vscprintf先求得所需要buffer的长度，然后malloc这个长度的buffer再用_vsprintf输出
[/Quote]

VC6.0没有这个函数。。。

[沙漠里的海豚]

看看这个吧，MSDN里的例子

// crt_vsprintf.c
// compile with: /W1
// This program uses vsprintf to write to a buffer.
// The size of the buffer is determined by _vscprintf.

#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>

void test( char * format, ... )
{
    va_list args;
    int     len;
    char    *buffer;

    // retrieve the variable arguments
    va_start( args, format );
    
    len = _vscprintf( format, args ) // _vscprintf doesn't count
                                + 1; // terminating '\0'
    
    buffer = (char*)malloc( len * sizeof(char) );

    vsprintf( buffer, format, args ); // C4996
    // Note: vsprintf is deprecated; consider using vsprintf_s instead
    puts( buffer );

    free( buffer );
}

int main( void )
{
   test( "%d %c %d", 123, '<', 456 );
   test( "%s", "This is a string" );
}

[e_sharp]

UP

[青葱岁月不可追]

[Quote=引用楼主 handsome1024 的帖子:]
刚遇到一个问题：
把一段不确定长度的字符串，写到申请的内存空间里。
由于不确定长度，所以用malloc申请的时候，想做个判断，比如先申请1024，如果不够，则加倍申请，直到足够。

请问这段代码如何实现。
[/Quote]
个人认为最好的方法是用 命令行参数

int main(int argc,char *argv[])

先用strlen判断一下字符串长度

然后一次malloc到足够长度，之后再strcpy

当然如果用命令行参数的话，完全可以不malloc空间，直接使用argv[n]

[lockhall]

用string来替代你的申请内存吧；

省事……

[sevenhu]

先扫一下字符串长，再malloc一块地址不行么？

[jxc25]

你申请个4kb
总够用吧
申请不来
就减半

[牛耳朵]

乞丐发个40分的贴不容易啊。。。哭~~~

[Longinc]

试试分段处理

[bpboy2008]

字符串的话就好办
内存的话, 你必须知道其长哦

既然字符串,为什么不先求长度呢?不明白

[jingyuge]

你可以用一个空间申请一个。这样就能保证都有效了
给你一段我写的代码参考下

#include <stdio.h>
#include <stdlib.h>

struct Node         /*定义 Node 结构体类型*/
{
	int nData;      /*存储数据的变量*/
	Node *pNext;    /*存储指向下一个节点的指针*/
};                  /*定义 Node 结构体类型 结束*/

void main()
{
	Node *pHead = NULL;          /*头指针*/
	Node *pPrevious = NULL;      /*用于连接节点时指向 上一个节点 的指针*/
	Node *pNew = NULL;           /*用于连接节点时指向 新节点 的指针*/
	int nCount = 0;              /*计数器，每生成一个新节点就自加1，以纪录一共生成了多少个节点*/
	int i = 0;                   /*控制循环的变量*/
	void SortNum(Node *pHead, int nN);  /*声明一个排序的函数*/

	printf("请输入你想排序的数(输入 q 结束输入)：");
	do
	{
		pNew = (Node *)malloc(sizeof(Node));  /*分配新空间以生成新节点，用pNew指针指向*/
		scanf("%d", &pNew->nData);  /*读取数据到新节点的数据域*/
		pNew->pNext = NULL;  /*生成的新节点的 下一个 指针指向 空*/
		nCount++;  /*每生成一个新节点计数器自加1*/
		if (NULL == pHead)  /*如果生成的是第一个节点，让头指针pHead指向它*/
		{
			pHead = pNew;
		}
		if (NULL == pPrevious)  /*如果生成的是第一个节点，让 上一个 指针pPrevious指向它，以便下一句 pPrevious->pNext 不为NULL*/
		{
			pPrevious = pNew;
		}
		pPrevious->pNext = pNew;  /*将上一个节点的 pNext指针指向新生成的节点以连接链表*/
		pPrevious = pNew;         /*然后将pPrevious指向新生成的节点，以便再生成新节点时连接链表*/
	}while('q' != getchar());  /*如果读取到字符'q'便停止读取数据*/
	nCount--;  /*因为最后多生成了一个节点读取'q'，故自减1 得到需要排序的数的个数*/
	printf("你输入了%d个数\n",nCount);
	printf("从小到大排序的结果为：\n");
	SortNum(pHead,nCount);  /*调用排序函数*/

	system("pause"); /*调用暂停函数方便观看结果*/
}

void SortNum(Node *pHead, int nN)  /*起泡排序法，就不多说了*/
{
	int i = 0;
	int j = 0;
	int nTemp = 0;
	Node *pCurrent = pHead;

	for (i = 1; i <= nN - 1; i++)
	{
		for (j = 1; j <= nN - i; j++)
		{
			if (pCurrent->nData > pCurrent->pNext->nData)
			{
				nTemp = pCurrent->nData;
				pCurrent->nData = pCurrent->pNext->nData;
				pCurrent->pNext->nData = nTemp;
			}
			pCurrent = pCurrent->pNext;
		}
		pCurrent = pHead;
	}
	for (i = 1; i <= nN; i++)
	{
		printf("%6d", pCurrent->nData);
		pCurrent = pCurrent->pNext;
	}
	printf("\n");
	
	return;
}

[牛耳朵]

[Quote=引用 3 楼 bpboy2008 的回复:]
字符串的话就好办
内存的话, 你必须知道其长哦

既然字符串,为什么不先求长度呢?不明白
[/Quote]

字符串也使用指针传过来的，无法求长度。。。

[xhs_lh04]

先申请的buf


if (reqlen >1024)
{
char *tmp = (char *)realloc(buf, 1024*2);
if ( NULL== tmp)
return -1;
buf = tmp;
}

[牛耳朵]

我把我写的代码贴上来吧，这样直观一些。
由于是不定参数，所以没法判断要往buffer里写的类型和长度

#include "stdafx.h"
#include <stdio.h>
#include <stdarg.h>
#include<stdlib.h>  


void Logprintf(const char *Path,char *format, ... )
{
	char *buffer;
	buffer=(char*)malloc(1024);//在这里想先申请1024，如果不够再双倍申请
	if(buffer == NULL) exit(0);

	FILE *f1;

    if ((f1=fopen(Path,"wt+"))==NULL)
    {
        printf("can not open infile\n");
        exit(0); 
    }

   va_list v;
   va_start(v, format);
   vsprintf(buffer,format,v); //在这个地方往buffer里写 
   va_end(v);

   printf("%s\n",&buffer);       
   fprintf(f1,"%s",&buffer);     //write to the file
   fclose(f1);
}
int main()
{
	Logprintf("F:\\wr1.txt","%d%s",23,"sadfsdf");//这里的几个参数是不确定的，什么类型的也不确定
}

[clhposs]

C++ vector容器就是这样的

[牛耳朵]

上面代码已经解决，感谢上面各位回答的朋友。晚上下班的时候揭帖。

#include "stdafx.h"
#include <stdio.h>
#include <stdarg.h>
#include<stdlib.h>  
 

void Logprintf(const char *Path,char *format, ... )
{
  char *buffer = NULL; int len;
 
  FILE *f1;
  if ((f1=fopen(Path,"wt+"))==NULL)
  {
    printf("%s can not open!\n",Path);
    return;
  }
 
  va_list v;
  va_start(v, format);
  len=_vscprintf(format,v)+1;
  buffer=(char*)malloc(len*(sizeof(char)));
  if(buffer == NULL) 
  {
     printf("Insufficient memory available\n");
     fclose(f1);
     return;
  }
  vsprintf(buffer,format,v);  
  va_end(v);
  printf("%s\n",buffer);       
  fprintf(f1,"%s",buffer);
  fclose(f1);
  free (buffer);
  buffer=NULL;
}
int main()
{
  Logprintf("F:\\wr1.txt","%d\n%s\n%2.1f",23,"sdddddd",44.0);
}