相关疑难解决方法(0)

我有以下代码.

#include <iostream>

int * foo()
{
    int a = 5;
    return &a;
}

int main()
{
    int* p = foo();
    std::cout << *p;
    *p = 8;
    std::cout << *p;
}

而代码只是运行而没有运行时异常!

输出是 58

怎么会这样？本地变量的内存不能在其功能之外无法访问吗？

我所知道的是全局和静态变量存储在.data段中,未初始化的数据存在于.bss段中.我不明白的是为什么我们有未初始化变量的专用段？如果未初始化的变量在运行时分配了值,那么该变量是否仅存在于.bss段中？

在以下程序中, a是在.data段中,并且b在.bss段中; 那是对的吗？如果我的理解是错误的,请纠正我.

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

int a[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9};
int b[20]; /* Uninitialized, so in the .bss and will not occupy space for 20 * sizeof (int) */

int main ()
{
   ;
}  

另外,请考虑以下程序,

#include <stdio.h>
#include <stdlib.h>
int var[10];  /* Uninitialized so in .bss */
int main ()
{
   var[0] = 20  /* …

有人可以向我解释一下创建带有和不带有 malloc 的结构之间的区别吗？什么时候应该使用malloc，什么时候应该使用常规初始化？

例如：

struct person {

    char* name;

};

struct person p = {.name="apple"};

struct person* p_tr = malloc(sizeof(struct person));
p_tr->name = "apple";

两者之间到底有什么区别？什么时候会使用一种方法而不是其他方法？

我正在尝试使用c ++编写motorbee

当我运行代码时,我收到以下错误:

运行时检查失败#0 - ESP的值未在函数调用中正确保存.这通常是调用使用一个调用约定声明的函数和使用不同调用约定声明的函数指针的结果.

这是我的代码.

#include "stdafx.h"
#include <iostream>
#include "windows.h"
#include "mt.h"
using namespace std;

HINSTANCE BeeHandle= LoadLibrary("mtb.dll"); 
Type_InitMotoBee InitMotoBee;
Type_SetMotors SetMotors;
Type_Digital_IO Digital_IO;
void main ()
{   
    InitMotoBee = (Type_InitMotoBee)GetProcAddress( BeeHandle,"InitMotoBee");
    SetMotors =(Type_SetMotors)GetProcAddress(BeeHandle,"SetMotors");
    Digital_IO =(Type_Digital_IO)GetProcAddress(BeeHandle,"Digital_IO ");
    InitMotoBee();

    SetMotors(0, 50, 0, 0, 0, 0, 0, 0, 0);

}

我在内存受限的环境中工作,需要动态创建字符串,但仍然没有占用堆内存.这是否有意义:

static char staticStringBuffer[10240];
static size_t staticStringWatermark = 0;

void createString( const char * something, const char * somethingElse ) {
    char buf[1024];
    strcat(buf, "test");
    strcat(buf, something);
    strcat(buf, somethingElse);

    strcat(&staticStringBuffer[staticStringWatermark], buf);
    staticStringWatermark += strlen(buf+1);
}

这可能是编译,但我正在尝试理智 - 为堆内存牺牲静态内存？

谢谢你^ _ ^

我在Linux环境中使用C编程语言来读取目录中的文件.我已经包含#include<dirent.h>在我的代码中并使用了该函数readdir().

根据Linux在线页面,它说不会调用free()结果指针到dirent结构,因为它可能被分配在堆栈上.

你能帮我理解它是如何工作的吗？我不明白为什么我们不必删除struct dirent.什么时候删除谁删除它？

以下是我所说的摘录:

成功时,readdir()返回指向dirent结构的指针.(此结构可以静态分配;不要尝试free(3)它.)如果到达目录流的末尾,NULL则返回并且errno不会更改.如果发生错误,NULL则返回并errno适当设置.

我知道以下情况的区别：

case 1: int a[10];

对于情况 1，数组的内存在堆栈上分配。

case 2: int *a = new int[10];

对于情况 2，在堆上分配内存并返回一个指针。

但是下面两个声明有什么区别，因为向量内存总是分配在堆上

vector<int> v1;
vector<int> *v2 = new vector<int>();

当您为内存分配空间时，如何判断是否需要为其分配更多空间？是否有检查或您可以对新内存进行检查以确保它运行正常？（为结构分配内存）。

因为我在想的是，结构是一组数据，即使我传递了很多数据，它也永远不需要超过结构正确的大小？

我开始学习C,我不知道为什么应用程序不断崩溃.

#include <stdio.h>
#include <string.h>

typedef struct
{
    char name[50];
    int age;
}person;

void initPerson(person *aPerson, char name[50], int age)
{
    strcpy(aPerson->name, name); // <- causes a crash
    aPerson->age = age; // <- causes a crash
    printf("%s", aPerson->name);
}

int main()
{
    person *myPerson;
    initPerson(myPerson, "Oscar", 45);

    printf("%s, %i", myPerson->name, myPerson->age);
    return 0;
}

我已经标记了导致崩溃的线条.谁能告诉我这是什么问题？

我现在正在学习 C 并试图弄清楚 C 的内存管理是如何工作的。如果我错了，请纠正我，但据我所知：

静态内存分配 - 这发生在编译时。编译器为静态内存分配必要的内存。

静态内存释放 - 当块/函数完成运行（对于局部变量）或当整个程序完成执行（对于全局变量）时，内存会自动释放。

动态内存分配 - 在运行时分配内存，因为此时输入的大小未知。

动态内存释放 - 执行 free() 时释放内存。

这是对的吗？我错过了什么吗？

我是C++的新手,我目前正在学习它.
当我在探索网络和问题时,我遇到了下一个代码:

class A
{
    public:
    ~A() { cout << "A"; }

};

class B
{
    public:
        ~B() { cout << "B"; }
};


int main()
{
    A a;
    B b;

    return 0;
}

输出看起来像这样:

BA

有人可以解释为什么输出看起来像这样？

我知道在动态内存分配的情况下使用堆,否则使用堆栈.我尝试过静态内存分配和动态内存分配之间 的区别我知道差异,但混淆是关于它们的生命周期.