一些小练习

最新推荐文章于 2020-09-22 20:49:08 发布

wen0006

最新推荐文章于 2020-09-22 20:49:08 发布

阅读量605

点赞数

分类专栏： C++/VC++ 文章标签： insert null variables 存储 struct 多线程

本文链接：https://blog.csdn.net/wen0006/article/details/5680125

版权

C++/VC++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

1. 指针参数

void f(char *p)

{

p=(char *)malloc(10);

}

int main()

{

char *p=NULL;

f(p);

free(p);

return 0;

}

free(NULL)是可以的，只是指针变量做函数参数仍然是单向的值传递，p指针仍然是0，所以这里内存泄露了。

2.字符数组

char s1[24]="how are u";

char s2[24]="how are you";

int i,len = strlen(s2);

for (i=0;i<len;i++)

s1[i]=s2[i];

printf("s1=%s s2=%s/n",s1,s2);

这里s1和s2都能正常显示，因为s1后面全是自动补0.

3.void指针转换

class A
{
public:
    A():a(2),p((void *)5)
    {
        printf("a=%d p=%d/n",a,p);
    }
    int a;
    void *p;
};
int main()
{
   A b;
}

这里p一定要用(void *)强制转换，但p的值是5，引用它会造成系统受影响。

4.堆内存，数据段，代码段

#include <stdio.h>

char *f1()

{

char a[]="Hello, world!!";

return a;

}

char *f2()

{

char *a="Hello, world!!";

return a;

}

char *f3()

{

static char *a="Hello, world!";

return a;

}

void main()

{

char *s1;

char *s2;

char *s3;

s1=f1();

s2=f2();

s3=f3();

puts(s1);

puts(s2);

puts(s3);

}

一个程序在内存中，按照内存地址从低到高的顺序，分布着代码段、常量段、数据段、堆内存和栈内存

代码段用来存放程序的机器码

常量段用来存放所有的字符串常量

数据段用来存放全局变量和静态变量（这个段在程序加载后自动清0，这就是为什么全局变量和静态变量的初始值都是0）

代码段、常量段和数据段内存都是和程序的生命周期相同的，只有程序结束后，该内存才会被释放。数据段又分为已初始化数据段和未初始化数据段，未初始化数据段不影响目标文件的大小。

堆内存，程序中用malloc等内存分函数申请的内存块，从数据段顶端开始，从低地址向高地址分配。必须调用free等内存释放函数，将不使用的内存释放。

栈内存，存放函数内的临时变量，程序每进入一个函数前，从栈内存内分配一块内存，大小等于该函数内的临时变量的大小，当函数结束后，该内存被自动释放。栈内存从高地址向低地址方向分配。

堆内存和栈内存在被分配出去后是不会重新初始化的，所以分配的时候内存中放的什么数据，你得到的内存中就是什么数据。这就是为什么临时变量和malloc的内出中的数据是随机值的原因。

下面我们来看看前面提到的几种情况：

1) . char a[] = " Hello,world! ";

a是局部字符数组变量，数组大小为13，数组内的元素被初始化为"Hello,world! /0 "。

a被存储在函数f1的栈内存中，return a将a的首地址返回回去了。f1函数结束后，f1的栈内存被释放，原来a所在的内存地址可能被挪做它用，所以那个地址里面放的是什么东西不得而知，因此 puts输出该地址中的内容得到的结果是随机的。

2 ) . char *a = " Hello,world! ";

a是一个char*指针变量，大小为4个字节，其值是" Hello,world! "这个常量字符串的首地址。 " Hello,world! "常量字符串被保存在常量段，不能被更改。

a被存储在函数f1的栈内存中，return a返回的是指针a的值，即 " Hello,world! "常量字符串的首地址。f1函数结束后，a被释放了，但a 指向的常量段的内容没有变。因此puts输出是正确的。

3 ) . static char a[] = " Hello,world! ";

a是静态字符数组变量，数组大小为13，数组内的元素被初始化为"Hello,world! /0 "。

a被存储在数据段内，return a将a的首地址返回回去了。f1函数结束后，a所在的内存不会被释放，因此puts输出该地址中的内容得到的就是a中存储的字符串。

5.单链表反转

struct tagT
{
int data;
struct tagT *next;
};

typedef struct tagT T;

T *revert(T *head)
{
   T *p=head, *pnext=NULL, *newHead=NULL;
while(p!=NULL)
{
      pnext=p->next;
      p->next=newHead;
      newHead=p;
      p=pnext;
}
return newHead;
}

T *insert(T *head, int data)
{
    T *newNode = (T *)malloc(sizeof(T));
    memset(newNode,0,sizeof(T));
    newNode->data = data;
    newNode->next = NULL;

    T *p=head;
    if ( NULL == p )
    {
          /* no one node */
          return newNode;
    }
    else
    {
        /* point to end */
        while ( p->next!=NULL )
       {
          p=p->next;
        }
        /* insert */
        p->next = newNode;
        return head;
     }
}

void print(T *head)
{
     T *p=head;
     while (p!=NULL)
    {
        printf("%2d ", p->data);
        p=p->next;
    }
    printf("/n");
}

int main()
{
    T *head = NULL;
    head = insert(head,1);
    head = insert(head,2);
    head = insert(head,3);
    print(head);

head = revert(head);
print(head);

return 0;
}

6.两个大数相乘

char *multi(char *a, char *b)
{
    int n=strlen(a), m=strlen(b);
    int i=0,j=0;
    int temp=0;
    int *c=(int *)malloc(sizeof(int)*(n+m));
    memset(c,0,(n+m)*4);

    for ( i=0;i<n;i++)
        for (j=0;j<m;j++)
            c[i+j+1]+=(a[i]-'0')*(b[j]-'0');

    for ( i=n+m-1;i>=0;i--)
    {
        if ( c[i]>=10 )
        {
            c[i-1]+=c[i]/10;
            c[i]=c[i]%10;
        }
    }

    char *p, *result=(char *)malloc(n+m+1);
    memset(result,0, n+m+1 );
    i=0;
    while (c[i]==0)
        i++;
    p=result;
    for (;i<n+m;i++,p++)
        (*p)=(c[i]+'0');
    return result;
}