常量字符* 返回类型

const char* Return Type

本文关键字：返回类型 字符 常量      更新时间：2023-10-16

我有一个返回常量字符* 的函数 

const char* SayHi()
{
string data="Mustafa Hi";
const char* cptr=data.c_str();
return cptr;
}
int main()
{ 
cout<<SayHi()<<endl;
return 0;
}

但输出不是：穆斯塔法 嗨。它是空的。

如果我将数据变量定义为全局变量，例如

  string data;
  const char* SayHi()
  {
     data="Mustafa Hi";
     const char* cptr=data.c_str();
     return cptr;
  }
  int main()
  {
     cout<<SayHi()<<endl;
     return 0;
  }

输出是穆斯塔法嗨。

但是对于 const int* 这有效;

    const int* aMethod()
    {
    int* aVar=new int(111);
    const int* acstPtr=aVar;
    return acstPtr;
    }
    int main()
    {
         cout<<*aMethod()<<endl;
         return 0;
    }

输出 ： 111
或

const int* aMethod()
    {
    int aVar =111; //in stack
    const int* acstPtr=&aVar;
    return acstPtr;
    }

那么为什么不为空呢？

第一个实现的问题在于返回指向临时内存的指针。由于"字符串数据"变量仅在该函数的范围内定义，因此当函数消失时，您刚刚返回的指针现在指向释放内存。在您的情况下，它必须被所有零覆盖。这就是您看到 NULL 的原因。

因为在C++对象有生命周期。在第一个示例中，退出函数后字符串将不再存在。因此，返回指向该字符串数据的指针是错误的。

你需要明白，SayHi 中的"字符串数据"是一个局部变量。当函数退出时，局部变量将被销毁。

要执行您尝试执行的操作，您必须为字符串创建存储，以便它不是 SayHi 的本地存储，无论是在 main 中传递还是在堆上传递。也许您希望 SayHi 返回引用。

试试下面的代码。如果要返回指向局部变量的指针，则需要使用 static 关键字。所有局部变量在函数存在后都将是自由的。这就是无法正确返回字符串的原因。

const char* SayHi()
{
    static string data="Mustafa Hi";
    const char* cptr=data.c_str();
    return cptr;
}

But output is not : Mustafa Hi. It is null.

它可以是任何东西。问题在于返回局部对象(字符串(的成员变量(const char *(，一旦我们从封闭的大括号中出来，就会清理它。在这种情况下，输出是未定义的。在少数编译器上，如果未重新分配释放的内存，您甚至可以获得所需的输出。

它适用于全局变量，因为它们跨越程序的整个生命周期，并且在控件退出 SayHi(( 后不会被清理

 const int* this works;

这是动态内存分配，而不是之前的堆栈分配。与堆栈分配(创建本地对象(不同，使用堆分配(使用 new(时，您拥有内存和值，直到显式删除内存。

要使用 int 复制第一个场景，您的代码应该是这样的：

const int* aMethod()
    {
    int aVar=111; // changed from pointer to local variable. Heap to stack
    const int* acstPtr= &aVar; //Returning the address for local variable. Which will be freed at the enclosing curly brace.
    return acstPtr;
    }

但同样，当您处理内存已释放的指针(悬空指针(时，输出是未定义的

局部变量是在"堆栈"上创建的，这些变量具有它们存在的范围的生存期。特别是，在您的原始案例中发生了什么：

string data="Mustafa Hi";
const char* cptr=data.c_str();
return cptr;

由于std：：string是一个带有析构函数的对象，因此变得复杂。在 C++11 之前，除非您调用 c_str((，否则它可能已经存储了不以零结尾的字符串。在内部，它包含一个指针和一个大小值，可能还包含一个容量值。它分配内存来存储字符串。想想(C++11 之前(std：：string 像这样：

class String {
    char* m_ptr;
    size_t m_length;
    size_t m_alloc;
public:
    String() : m_ptr(nullptr), m_length(0), m_alloc(0) {}
    String(const char* src) {
        size_t length = strlen(src);
        m_ptr = new char[length];
        m_alloc = m_length;
        memcpy(m_ptr, src, length); // not including the 
    }
    const char* c_str() {
        if (m_length == 0)
            return nullptr;
        if (m_alloc > m_length) // we're null terminated
            return m_ptr;
        char* newPtr = new char[length + 1];
        memcpy(m_ptr, newPtr, length);
        delete [] m_ptr;
        m_ptr = newPtr;
        m_ptr[length] = '';
        ++m_alloc;
        return m_ptr;
    }
    ~String() {
#ifdef _DEBUG
        if (m_ptr) m_ptr[0] = 0;
#endif
        delete [] m_ptr;
    }
};

您的函数正在获取此对象的实例的地址，然后返回该地址。接下来发生的事情是实例超出范围并调用它的析构函数 - 它在堆栈上并且紧跟在您的代码之后，因此它所在的堆栈位置现在可供接下来调用的任何代码使用。

查看以下示例(现场演示：http://ideone.com/wAcY3B(

#include <iostream>
int* getInt1(int input)
{
    int i = input;
    std::cout << "created 'i' at " << (void*)&i << std::endl;
    int* ptr1 = &i;
    return ptr1;
}
int* getInt2(int input)
{
    int* ptr3 = new int(input);
    return ptr3;
}
int main()
{
    int i = 0;
    std::cout << "i is on the stack, it's address is " << (void*)&i << std::endl;
    int* ip = new int(1);
    std::cout << "ip is on the heap, it's address is " << (void*)ip << std::endl;
    int* p1 = NULL;
    int* p2 = NULL;
    int* p3 = NULL;
    // force the pointers to be assigned locations on the stack by printing them.
    std::cout << "created p1(" << &p1 << "), p2(" << &p2 << ") and p3(" << &p3 << ")" << std::endl;
    p1 = getInt1(10101);
    std::cout << "p1(" << &p1 << ") = " << (void*)p1 << " -> " << *p1 << std::endl;
    p2 = getInt1(20202);
    std::cout << "p2(" << &p2 << ") = " << (void*)p2 << " -> " << *p2 << std::endl;
    // but more importantly
    std::cout << "p1(" << &p1 << ") = " << (void*)p1 << " -> " << *p1 << std::endl;
    p3 = getInt2(30303);
    std::cout << "p3(" << &p3 << ") = " << (void*)p3 << " -> " << *p3 << std::endl;
    std::cout << "p2(" << &p2 << ") = " << (void*)p2 << " -> " << *p2 << std::endl;
    std::cout << "p1(" << &p1 << ") = " << (void*)p1 << " -> " << *p1 << std::endl;
}

输出如下所示：

i is on the stack, it's address is 0xbfb49a90
ip is on the heap, it's address is 0x9b83008
created p1(0xbfb49a94), p2(0xbfb49a98) and p3(0xbfb49a9c)
created 'i' at 0xbfb49a6c
p1(0xbfb49a94) = 0xbfb49a6c -> 10101
created 'i' at 0xbfb49a6c
p2(0xbfb49a98) = 0xbfb49a6c -> 20202
p1(0xbfb49a94) = 0xbfb49a6c -> -1078682988
p3(0xbfb49a9c) = 0x9b83018 -> 30303
p2(0xbfb49a98) = 0xbfb49a6c -> -1078682988
p1(0xbfb49a94) = 0xbfb49a6c -> -1078682988

由于堆栈指针在调用"getInt1(("之间不会更改，因此局部变量实例位于同一位置，但是如果您在赋值之间调用其他一些随机函数，它们将使用相同的堆栈位置，并且指向的值将丢失。

相关文章：