返回指向静态局部变量的指针是否安全？
返回指向静态局部变量的指针是安全的。静态局部变量是在函数内部声明的，但它们的生命周期与整个程序相同。这意味着它们在函数被调用时分配内存，并在程序结束时释放内存。因此，返回指向静态局部变量的指针是安全的，因为该变量的生命周期足够长，可以确保在使用指针时该变量仍然有效。
例如，以下代码是安全的：
int* foo() {
static int x = 42;
return &x;
}
int main() {
int* p = foo();
// 使用指针p
return 0;
}在这个例子中，foo() 函数返回一个指向静态局部变量 x 的指针。由于 x 的生命周期与整个程序相同，因此在 main() 函数中使用指针 p 是安全的。
相关·内容
1回答
我已经读过，我们不应该返回指针或对局部变量的引用。因此，在下面给出的示例中，我了解到当我编写：return f; in函数foo时，我返回一个指向局部变量的指针。而使用函数外部的指针，将导致未定义的行为。
#include <iostream>
const char* foo()
{
const char* f = "ffdf";
return f;//returning pointer to a local variable
}
const char* func()
{
return "fsfs";
}
int mai
浏览 2提问于2022-03-31得票数 3
回答已采纳
2回答
我有一个模板函数，它将接收一个枚举数，并将其转换为一个C风格的以null结尾的字符串。我知道这个程序有一个逻辑错误，因为函数的局部变量是通过引用作为返回值返回的。但是，程序在执行时不会出现错误或警告(Visual Studio 17)。这是否会导致任何未定义的行为或内存泄漏？当str超出作用域时，是否返回地址的副本并销毁指针变量？这是一个好的编程实践吗？
我能想到的另一个选择是创建一个动态内存。例如，const char* str = new char[size]。
#include <iostream>
#include <string>
namespace Let
浏览 0提问于2018-10-09得票数 1
struct SGetWindow
{
HWND__* pWindow;
};
SGetWindow getWindow;
EnumWindows(GetWindowProc, reinterpret_cast<LParam>(&getWindow));
return getWindow.pWindow;
使用SGetWindow结构作为LParam，成功地更新了HWND__* pWindow。
我想知道本地struct变量返回成员变量的使用是否安全。
return getwindow.pWindow;
安全吗？或者导致不明确的行为？
编辑：-我添加了一个图像来理解
浏览 5提问于2020-03-10得票数 3
考虑以下代码：
struct mystruct {
int data;
struct mystruct *next;
};
void myfunc ()
{
struct mystruct s1;
s1.data= 0;
s1.next = NULL;
myfunc2(&s1);
..
..
}
将此本地结构的地址传递给其他函数是否安全。这个本地结构是否可以在函数外部使用，或者它已经释放了？
浏览 0提问于2011-06-21得票数 4
回答已采纳
3回答
这是密码，
char *foo()
{
static char s[10] = "abcde";
return s;
}
char *bar()
{
char *c = foo();
return c;
}
int main()
{
printf("%s\n", bar());
}
通常，像我在bar中那样返回本地指针是错误的，但是现在c指向foo返回的static变量，在bar中返回本地变量c是否正确？
我试过了，它的printf值是正确的，但我不明白它是如何工作的。我想，当bar()结束时，var c应该消失，这
浏览 12提问于2012-02-24得票数 6
回答已采纳
2回答
我一直在使用C，我认为指针不应该指向局部变量，但库中有一个gmtime()函数，它似乎返回一个指向在其中创建的变量的指针。我的理解正确吗？
time_t epochTime;
time(&epochTime);
struct tm *currentTime=gmtime(&epochTime);
浏览 2提问于2020-06-18得票数 0
我在学习系统编程。
有那么多函数返回静态分配的变量。
其中之一，是getpwnam()。
所以，在我所读的书的例子中：
printf("%ld %ld\n", (long)(getpwnam("tsr")->pw_uid), (long)(getpwnam("avr")->pw_uid));
两者都返回相同的uid，尽管在/etc/passwd中，它们的uid是不同的。解释原因。
这就是问题所在。
但是，我认为这是因为静态分配变量。但是，结果是输出是不同的(例如，3001,3005)。
为什么输出是不同的？
根据这本书，输出应该是一样
浏览 4提问于2016-05-05得票数 1
回答已采纳
2回答
与时间相关的函数和多线程
、、、
我正在使用Linux (使用libc-2.12.so的CentOS 6.3发行版)。
我想知道C库函数time()、localtime()、mktime()是否可以在多线程环境下使用。
仅举一个例子(不一定是我的项目代码)：
#include <stdio.h>
#include <time.h>
int main()
{
time_t timep;
struct tm *p;
for (int i = 0; i < 1000; ++i)
{
time(&timep);
printf("time() :
浏览 2提问于2013-08-21得票数 1
回答已采纳
3回答
C++中的单例模式
、、、
我是个新手，对C++有点陌生，我遇到过一段使用单例模式的C++代码，
class CFoo
{
public:
static CFoo& getInstance()
{
static CFoo self;
return self;
}
private:
CFoo(){}
~CFoo(){}
};
我只是搞不懂为什么要返回静态引用？这是有效的代码吗？为什么程序员不使用指针？
浏览 1提问于2010-11-03得票数 4
回答已采纳
4回答
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<stdbool.h>
char** parser(char *message)
{
char a[9][256];
char* tmp =message;
bool inQuote=0;
int counter=0;
int counter2=0;
while(*tmp!='\0')
{
switch(*tmp)
{
浏览 0提问于2011-02-16得票数 0
回答已采纳
2回答
返回指向本地结构的指针
、、、、
在C中返回指向局部结构的指针安全吗？我的意思是正在做这个
struct myStruct* GetStruct()
{
struct myStruct *str = (struct myStruct*)malloc(sizeof(struct myStruct));
//initialize struct members here
return str;
}
安全吗？
谢谢。
浏览 0提问于2009-09-25得票数 6
回答已采纳
如果我有以下两个函数
std::string foo1()
{
std::string temp;
...
return temp;
}
和
const char* foo2()
{
std::string temp;
...
return temp.c_str();
}
和一个接受常量char*作为输入的函数；
void bar(const char* input) { ... }
哪一个更安全：
bar(foo1().c_str());
或
bar(foo2());
如果我只想将一个字符串作为输入传递给bar，然后不关心任何一个foo函数的返
浏览 1提问于2013-02-07得票数 2
回答已采纳
可能重复：
double* weird( double a, double b )
{
double c;
c = pow( a + b, 0.5 );
return &c;
}
对你们中的大多数人来说，这可能是微不足道的，但我不认为这里会出什么问题。
浏览 8提问于2012-10-21得票数 0
回答已采纳
我知道，这是一个非常非常普遍的问题。我读过，，等。我曾经认为返回局部变量的地址是一个非常糟糕的主意。我以前认为你应该：
通过例如malloc分配内存
使局部变量保持静态或
将指针作为参数传递
但后来我试了一下：
#include <stdio.h>
char * foo_1();
char ** foo_2();
int main() {
char * p_1 = foo_1();
char ** p_2 = foo_2();
printf("\n [%s] \n", p_1);
printf("\
浏览 4提问于2015-03-04得票数 2
回答已采纳
众所周知，在C++中从函数返回局部变量是不安全的，因为作用域的确定。在“有效的C++第三版”中，Scott在第101页的第21项中讲述了这个问题。不过，他最后说，正确的决定是：
inline const Rational operator*(const Rational& lhs, const Rational& rhs) {
return Rational(lhs.n * rhs.h, lhs.d * rhs.d);
}
这是不是也是一个不好的做法，而且这个函数是不安全的？
浏览 0提问于2014-07-16得票数 0
回答已采纳
我更改了这个源码：
GeomAPI_ExtremaCurveCurve ecc(
BRep_Tool::Curve(wd->Edge(i + 1), u11, u12),
BRep_Tool::Curve(wd->Edge(j + 1), u21, u22)
);
要这样做：
static Handle(Geom_Curve) c0 = BRep_Tool::Curve(wd->Edge(i + 1), u11, u12);
static Handle(Geom_Curve) c1 =
浏览 3提问于2020-02-04得票数 0
请看下面的代码示例。function fun_ret_loc_ptr()中的语句return (&i)返回警告：“function returns of local variable”。另一方面，函数fun_ret_loc_var()中的语句return a不能做到这一点。
#include <stdio.h>
int* fun_ret_loc_ptr()
{
int i = 10;
return (&i);
}
int fun_ret_loc_var()
{
int a = 20;
return a;
}
int main()
{
浏览 0提问于2011-11-18得票数 1
1回答
我已经考虑过了。代码是这样的：
#define IP_VAL(id) ({ \
char ip[32] = {0}; \
sprintf(ip,"192.168.0.%d",id&0xff); \
(char *)ip; \
})
它真的很有效，但我想知道问题是否会由宏造成？
我是这样使用的：
function(IP_VAL(id));
但我不确定这是绝对正确的。ip[32]是否超出了操作范围？
非常感谢您编辑我的问题：)
我测试了这个简单的示例，如下所示：
main(){
int a = 1;
int b = 2;
a
浏览 0提问于2016-11-08得票数 2
int* f(int* x) {
(*x)++;
return x; // Safe, x is outside this scope***
}
int& g(int& x) {
x++; // Same effect as in f()
return x; // Safe, outside this scope***
}
int& h() {
int q;
//! return q; // Error
static int x;
return x; // Safe, x lives outside this scope
}
int
浏览 6提问于2014-12-12得票数 0
回答已采纳
在我的C#应用程序中，我使用了IntPtr y = VoidPointer(x);，其中VoidPointer(x)是一个返回空*(空指针)的非托管函数。问题是我没有得到y在C#代码中指出的正确的值。我正在使用Marshal.ReadInt32(y)，并尝试过ReadByte，ReadInt64等。下面是代码片段，
C:非托管函数：
void* VoidPointer()
{
int Var1 = 7113;
return &Var1;
}
C#中的托管函数：(使用DllImport访问非托管函数。)
IntPtr z = VoidPointer();
Console
浏览 2提问于2011-07-20得票数 3
回答已采纳
关于lambda函数的快速问题。我看到，在使用gcc编译器时，如果没有捕获，就会隐式转换到lambda的操作符()函数指针。因此，看看下面这个经过淡化的示例，我应该期望这个函数的生命周期可以用于回调吗？定义的lambda函数的作用域是什么？本地范围，包范围，全局范围？在这种情况下，函数退出后调用lambda有问题吗？我在这里根本不想使用std::function，所以请不要对解决方案使用std::function返回值。我的问题是理解该函数的范围(没有捕获)，以及它是否可用于程序的生命周期。
#include <iostream>
typedef int(*fPtrT)(int,i
浏览 4提问于2014-04-21得票数 3
回答已采纳
我试图理解单例设计模式，并创建了一个最简单的模式：
#include <iostream>
class mySingleton{
private:
static mySingleton *ptr;
mySingleton(){ }
public:
static mySingleton* getInstance(){
if(!ptr){
ptr = new mySingleton();
return ptr;
} else return ptr;
}
void msg(){
浏览 5提问于2016-06-23得票数 0
回答已采纳
该函数用于将文本分割成不同的(可能是平衡的)块(我已经详细地讨论过它了， )。下面是代码(下面是问题描述)：
pair<off_t,off_t>* getSplits() {
struct stat st;
off_t size;
if (stat(file_name.c_str(), &st) == 0)
size = st.st_size;
int nMappers = size > nWorkers ? nWorkers : size; //if workers are greater than file size
浏览 6提问于2015-12-20得票数 0
回答已采纳
3回答
我有一个结构和一个返回Foo实例的函数，定义如下：
struct Foo
{
int a;
int* b;
};
struct Foo makeFoo(int a, int bSize)
{
struct Foo foo;
foo.a = a;
foo.b = malloc(sizeof(int) * bSize);
for (int i = 0; i < bSize; ++i)
foo.b[i] = i;
return foo;
}
最初，我认为foo是一个局部变量，当makeFoo返回时它就会消失，
浏览 0提问于2015-10-20得票数 1
3回答
最近遇到了以下代码，它声明了一个char * p，赋值如p="GOOD“，并返回返回p。当函数调用完成时，返回值是否有效？
const char * get_state(int state)
{
char *p;
if (state) {
p = "GOOD";
}
else
{
p = "BAD";
}
return p;
}
浏览 0提问于2013-04-10得票数 3
回答已采纳
鉴于以下职能：
void test(queue<string>* out) {
queue<string> abc = queue<string>();
abc.push("abc");
out = &abc;
}
理论上，abc变量是在堆栈上分配的，并且在函数的末尾必须自动弹出堆栈。但是，我将该变量的引用赋值给out参数，这是一个指针。因此，当调用此函数的上下文传递一个指针以捕获输出时，会发生什么情况？换句话说，这次行动安全吗？
为了明确这个问题，以下职能是否相当于上述职能：
void test(queue<
浏览 8提问于2022-01-04得票数 0
回答已采纳
3回答
在c#中，当在函数中创建和返回静态变量中的地址时，是否与初始化一个简单的
int sNum2 = 0 ; int * temp = &sNum2;
？静态内存中基本上会有它自己分配的大小，对吗？
从现在开始，我可以从staticNum函数中指向它吗？
也许不是一个好的做法，但它可以使用吗？
int * staticNum(){
int static sNum=0;
int * temp=&sNum;
sNum++;
return temp;
}
浏览 4提问于2022-01-13得票数 2
回答已采纳
4回答
我想通过引用一个函数来传递一个映射。代码如下：
void test(map<int, double *> &a);
int main(){
map<int, double *> a;
test(a);
cout << a[1][1] << endl;
return 0;
}
void test(map<int, double*> &a)
{
double red[] = {1.1, 2, 3};
a[1] = red;
}
问题是，a1应该是2。然而，当我执行程序时，
浏览 0提问于2013-04-18得票数 0
回答已采纳
我的问题类似于一些相关的问题，但这些问题的答案并不是我的主要困惑。我试着用最简单的形式提出这个问题。
我想返回一个在函数体中定义的数组。由于C++不允许按值返回数组，所以我声明函数返回指针。
为什么需要在函数体内声明这个数组才能在主程序中访问？我知道局部变量在退出函数体时就被销毁了，但是函数仍然返回指向这个数组的指针，不是吗？
float *doubleEachElement(float *arr)
{
static float result[3]; // static keyword is necessary
for (int i = 0; i != 3; i++) resu
浏览 2提问于2014-09-01得票数 0
回答已采纳
2回答
在堆栈上返回指针
、、
在C中，当我从函数返回堆栈创建变量的指针时，函数返回后内存就会丢弃，从而使指针不可能取消引用。但是在Go中，编译器并没有给我任何错误。这是否意味着这样做是安全的？
package main
import (
"fmt"
)
func main() {
fmt.Println(*(something()))
}
func something() *string {
s := "a"
return &s
}
浏览 5提问于2016-07-06得票数 13
回答已采纳
3回答
我试图从一个函数返回字符串数组并循环它：
string* fetchArray()
{
string myArray[10] = { "0" };
myArray[9] = { "End" };
return myArray;
};
int main()
{
string* fetchedArray = fetchArray();
while (*fetchedArray != "End")
{
cout << *fetchedArray << endl;
浏览 9提问于2016-02-28得票数 0
回答已采纳
5回答
我正在使用C语言编写的time.h文件，它可以帮助我们处理时间/日期函数。
我遇到了：
struct tm * _Cdecl localtime(const time_t *__timer);
...which似乎返回了一个指向tm结构的指针。我发现，按地址返回主要用于返回新的内存分配。
如果是这样，上面的返回实际上是如何工作的(struct tm的返回地址)。返回的对象是否定义在某个地方？
谢谢
浏览 5提问于2012-01-02得票数 41
回答已采纳
我正在使用99 99designs/gqlgen构建graphql，但我对返回指针的正确方式有点困惑。
graphql类型
type GraphType {
image_url: String
}
围棋代码是：
type GraphType struct {
ImageURL *string `json:"image"`
}
type T struct {
value string
}
func (t T) toImageUrl() string {
return fmt.Sprintf("http://test.localhost/%s
浏览 13提问于2022-10-20得票数 1
这是我第一次用C编写代码，我必须写一段代码，在字符串上执行upper操作，而不是实际使用to upper。
我已经这样做了，但由于某些原因，它最多只能使用8个字符。
以下是输入：
您好您好
下面是输出：
拷贝:您好您好
;▒
大写的字符串是HELLO HEp▒▒▒
原始字符串是hello
#include <stdio.h>
int strLength(char* str){
int count;
for(count=0;str[count] != '\n';count++){}
return count;
}
char* co
浏览 0提问于2020-03-05得票数 1
来自
“GlobalMemoryStatusEx函数返回的信息是不稳定的。不能保证对该函数的两个顺序调用将返回相同的信息。”
这是有意义的，但是我无法确定这是否是线程安全的。有谁知道这样或那样的方法吗？我试过在谷歌上搜索，但找不到这些信息。
浏览 1提问于2013-09-09得票数 2
回答已采纳
我为我在学校做的家庭作业写了这个函数：
char* getToken(char buffer[], int pos)
{
int i;
char copy[350], *token, *del = ",\n";
strcpy(copy, buffer);
token = strtok(copy, del);
for (i = 1; i < pos; i++)
token = strtok(NULL, del);
return token;
}
我希望它在给定的位置返回一个令牌，而不破坏原始
浏览 2提问于2016-03-11得票数 1
回答已采纳
3回答
在我们的讲座中，我们有以下例子：
int *foo(int x) {
return &x;
}
int* pt = foo(x);
*pt = 17;
这是一个糟糕的例子，但没有进一步解释。为什么这样不好？
浏览 7提问于2015-04-28得票数 4
回答已采纳
3回答
在一个函数中，如果我返回某个原始类型的对象的地址。我能确信它永远不会是一个NULL值吗？
我是否需要用如下语句检查NULL
if (r_value) { //do something }
else { //ERROR }
浏览 3提问于2014-09-30得票数 1
回答已采纳
我找了一段时间，没有找到类似的问题。(为这个问题想一个有意义的标题已经够难的了)
在编写一个从路径获取文件名的函数时，我意识到也许我可以通过在传递的path参数中返回一个指针来编写它，而不必为目标缓冲区分配内存。
我的问题是，像这样在传递的path参数中返回指针是否安全？
char *getFileFromPath(char *path, char slash)
{
char *file = path;
size_t len = strnlen(path, MAX_PATH);
if (len == MAX_PATH)
return NULL;
浏览 0提问于2015-01-11得票数 0
2回答
在这段代码中，我试图创建一个包含输入文件中所有字符的列表，而我的主要问题是“您不能返回函数的局部变量”Iv'e被告知，这让我非常困惑。我动态地分配了一个列表并返回它，--我可以在没有动态分配的情况下定义并返回它吗？我相信这是因为所有的信息都会被自动删除，我只会留下我创建的原始列表的地址。
下面是有关更多信息的代码：
typedef struct Item {
char tav;
struct Item* next;
} Item;
typedef struct List {
Item* head;
} List;
List* create(char* pat
浏览 1提问于2012-09-17得票数 0
5回答
我想写一行代码，因为有一个数组(std::vector<foo**>)，所以返回一个指向this的指针。我想使用一个引用(&this)，但它不起作用。
如果需要澄清，请告诉我。
编辑:为了弄清楚我在做什么，我尝试使用数组直接访问对象。像这样：(*ARRAY.at(i))->foo("bar");。有些人说做指针是不可能的。如果是这样，我如何使用数组直接访问对象？
浏览 0提问于2012-07-03得票数 3
回答已采纳
int * test1() {
int a = 4;
int * pa = &a;
return pa;
}
int * test2() {
int a = 4;
return &a;
}
这两种功能有什么区别？
test1函数返回一个没有问题的值，但是test2函数生成一个编译警告，不能返回局部变量的地址值。既然test1函数的pa变量也是局部变量，那么pa和pa的值不是在函数结束后消失了吗？test1函数的变量pa和变量pa是否存储在不同的内存区域？
浏览 5提问于2017-07-21得票数 0
3回答
以下函数是否安全，以返回指向局部变量的指针？
int * foo(void)
{
int a = 6;
int *p = &a;
return p;
}
如果没有，在什么条件下？如果是，编译器如何保证安全性？
试用的测试用例：
int * foo(void)
{
int a = 6;
int *p = &a;
return p;
}
int * bar(void)
{
int b = 7;
int *p = &b;
return p;
}
int main()
{
int a = *fo
浏览 5提问于2014-02-22得票数 0
回答已采纳
由fopen()创建和返回的FILE对象是动态变量还是静态变量？
在下面的示例中，
#include <stdio.h>
FILE *open_data(void) {
FILE *fp;
if ((fp = fopen("datafile", "r")) == NULL)
return (NULL);
return (fp);
}
由open_data()创建并返回的FILE对象是自动变量吗？如果不是，它的存储时间和链接是什么？
当对open_data()的调用返回时，open_data()创建并返回
浏览 2提问于2018-08-29得票数 0
我目前正在阅读有关time.h的手册。我走了这么远：
time_t now = time(0);
struct tm * local = localtime(&now);
现在我可以工作的时间，尽可能好，但我找不到信息，如果我的职责是free()变量local是否。
浏览 5提问于2016-01-27得票数 4
回答已采纳
3回答
，在clrscr之后发生了什么？
#include<stdio.h>
#include<conio.h>
int *call();
void main()
{
int *ptr;
ptr=call();
clrscr();
printf("%d",*ptr);
getch();
}
int*call()
{
int a=25;
a++;
return &a;
}
output:
-10
代码的工作方式如下:调用call()，调用a=25，然后调用a=26。地址是65518。此地址将返回给ptr。因为返回类型是int，而不是65518，所以
浏览 2提问于2013-11-22得票数 1
我不确定我创建局部变量的方式是否是未定义的行为。
N和L都持有指向临时堆栈地址的指针。这安全吗？编译器会忘记我正在使用指向堆栈地址的指针并用其他东西(例如其他局部变量)覆盖它吗？我知道一旦函数的作用域结束，它就不安全了。但我不确定下面的例子。任何洞察力都会很感激的。谢谢您抽时间见我。
struct Node { /* ... */ };
struct Node*
Node_setNode(struct Node* node)
{
/* ... */
return node;
}
struct List { /* ... */ };
void
List_push(struc
浏览 2提问于2014-03-06得票数 1
回答已采纳
这是一段简单的代码，我编写它来检查返回局部变量的地址是否合法，并且我的假设被编译器证明是正确的，编译器给出了相同的警告：
warning: function returns address of local variable
但执行时会打印出正确的地址...看起来很奇怪！
#include<stdio.h>
char * returnAddress();
main()
{
char *ptr;
ptr = returnAddress();
printf("%p\n",ptr);
}
char * returnAddress()
{
浏览 0提问于2011-05-25得票数 0
回答已采纳
3回答
从C函数返回数组
、、、
我正在尝试弄清楚在C中返回一个数组是如何工作的，这是代码。我要做的是保存一个数组，然后使用一个函数return来打印它。我在这里做错了什么？
#include <stdio.h>
#define DIM 50
char *func (char input[]);
int main(void)
{
char input[DIM];
printf("input? ");
fgets(input, DIM, stdin);
printf("output: %s", func(input));
return 0;
}
浏览 1提问于2013-05-24得票数 1
2回答
复合文字和指针
、、
以这种方式使用复合文本来初始化指针是安全的，完全可能吗？：
#include <stdio.h>
#include <string.h>
void numbers(int **p)
{
*p = (int []){1, 2, 3};
}
void chars(char **p)
{
*p = (char[]){'a','b','c'};
}
int main()
{
int *n;
char *ch;
numbers(&n);
chars(&a
浏览 0提问于2018-10-26得票数 1
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
