C/C++ 指针函数返回值的一些问题

1.指针函数

指针也是C语言中的一种数据类型，因此一个函数的返回值肯定可以是指针类型的。
返回指针的函数的一般形式为： 类型名 * 函数名(参数列表)

1.1举例1

#include <stdio.h>
#include <iostream>
using namespace std;


char  *returnStr()
{
   char* p = "tigerjibo";
   return p;
}
int  main()
{
   char* str;
   str = returnStr();
   //str[0] = 'T';   //会引起错误，不能修改只读数据段中的内容
   printf("%s\n", str);
   system("pause");
   return 0;
}

来分析下该程序。

（1）char  *p = “tigerjibo”。系统在栈上分配四个字节的空间存放p的数值。“tigerjibo”是字符常量，存放在只读数据段内。指向完后，系统把"tigerjibo"的地址赋值给p。

（2）函数用return 把p的数值返回。该数值指向只读数据段（该数据段内的数据是静态的不会改变）。退出子函数后，系统把p的数值销毁。但是p的数值已经通过return 返回。且只读数据段中的内容不会被修改和回收（其输于静态区域）

（3）在主程序中把该地址又给了str。因此str指向了“tigerjbo”。

（4）该程序虽然能运行，担又一个缺点，就是在程序中不能修改字符串常量中的数值。如果修改会引起段错误。

1.2举例2

#include<stdio.h>
char *returnStr()
{
           char p[]=”tigerjibo”;
           return  p;
}
int  main()
{
           char  *str;
           str =returStr();
           printf(“%s\n”,str);
}

编译该程序后，系统会提示如下警告：

function returns  address of local variable

（函数返回一个可变地址）
分析该错误：
1>”tigerjibo”是一个字符常量，存放在只读数据段中，是不能被修改的。
2>char p[],是一个局部变量，当函数被调用时，在 栈上开辟一个空间来存放数组p的内容。
3>char p[]=”tigerjibo”， 该语句是把”tigerjibo”的值赋值给数值p,存放在数组p地址处。而不是把”tigerjibo”的地址赋值给数组p。因此，“tigerjibo”此时在系统中有一处备份，一个在只读数据段中（不能修改，内容也不会被回收），一个在栈上存储（可以修改其内容，但函数退出后，其栈上存储的内容也会被回收）。
4>因此，当return p,返回了数组的首地址，但是当函数退出后， 其栈上的内容也将被丢弃，局部变量的内存也被清空了，因此该数组首地址处的内容是一个可变的值。

1.3举例3

#include<stdio.h>
char *returnStr()
{
           static char p[]="tigerjibo";
           return p;
}
int  main()
{
           char  *str;
           str =returnStr();
           str[0] = 'T';
           printf("%s\n", str);
}

此程序运行正确。
分析如下：
1>”tigerjibo”是一个字符常量，存放在只读数据段中，是不能被修改的。
2>static char p[],是一个 静态局部变量，在读写数据段中开辟一个空间给p用来存放其数值。
3>static char p[]=”tigerjibo”，该语句是把 ”tigerjibo”的值赋值给数值p, 存放在数组p地址处。而不是把”tigerjibo”的地址赋值给数组p。因此，“tigerjibo”此时在系统中有一处备份，一个在只读数据段中（不能修改，内容也不会被回收），一个在读写数据段中存储（可以修改其内容，当函数退出后，因其在读写数据段中存储，起内容不会被丢弃）。
4>因此，当return p,返回了数组的首地址，但是当函数退出后，虽然栈上的内容都清除了， 但是p地址是数据区中的地址，其上的内容不会被回收。

1.4举例4

#include<stdio.h>
#include<string.h>
#include<strdlib.h>
void getmemory(char *p)
{
        p = (char *)malloc(100);
}
int  main()
{
      char  *str=NULL;
      getmemory(str);
      strcpy(str,"helloworld");
      printf(“%s\n”,str);
}

编译后错误：

段错误

分析：在主程序中，str地址为空。在函数传递中将 str的地址传给了子函数中的指针p(是 拷贝了一份)，然后在 子函数中给p在堆上申请了一个100字节的空间，并把首地址赋值给p。但是函数传递中，p值改变 不会影响到主函数中str的值。因此,str的地址仍为空。在strcpy中引用空指针会出现段错误。

1.1至1.4摘自 http://blog.csdn.net/tigerjibo/article/details/7425571

1.5举例5

// 将字符串str中的小写字母变成大写字母，并返回改变后的字符串
// 注意的是：这里的参数要传字符串变量，不能传字符串常量
char * upper(char *str) 
{
    // 先保留最初的地址。因为等会str指向的位置会变来变去的。
    char *dest = str;
    
    // 如果还不是空字符
    while (*str != '\0') {
        // 如果是小写字母
        if (*str >= 'a' && *str <= 'z') {
            // 变为大写字母。小写和大写字母的ASCII值有个固定的差值
            *str -= 'a' - 'A';
        }
        
        // 遍历下一个字符
        str++;
    }
    
    // 返回字符串
    return dest;
}

里面的代码我就不详细解释了，重点看第2行的定义形式。
调用这个函数也非常简单：

int main()
{
    // 定义一个字符串变量
    char str[] = "lmj";
    
    // 调用函数
    char *dest = upper(str);
    
    printf("%s", dest);
    return 0;
}

输出结果： LMJ

上述摘自： http://www.cnblogs.com/mjios/archive/2013/03/19/2967037.html

1.5举例5

char *returnStr1(const char* instr)
{
	char* temp = const_cast<char *>(instr);
	char *outstr = new char[strlen(temp) + 1];
	memcpy(outstr, temp, strlen(temp) + 1);

	outstr[0] = 'E';
	return outstr;
}

int  main()
{
	char *str;
	char in_main[100];
	cin.getline(in_main, 100);

	str = returnStr1(in_main);
	printf("%s\n", str);
	delete(str);
	str = NULL;
	system("pause");
}

程序完成功能：对输入的字符串，第一个字符修改为E.如果在指针函数中使用new，在堆中分配了内存空间，并返回给主函数，这是不符合一般的程序书写规范的。另外，主函数中str在声明时没有进行初始化，也是不符合规范的。

为了在程序中避免内存泄漏，就必须确保对每个用new产生的指针调用delete（同理，对malloc产生的指针调用free），这里在子函数外部才能使用delete，如果程序员忘记释放内存，容易造成内存泄漏！！

条款31: 千万不要返回局部对象的引用，也不要返回函数内部用new初始化的指针的引用

2.函数指针

未完成