小编Sau*_*oat的帖子

我想我在代码中遗漏了一些东西。

下面是我在 C# 中的代码

public Form1()
    {
        InitializeComponent();
        serialPort1.PortName = "COM2";
        serialPort1.BaudRate = 9600;
        serialPort1.Parity = Parity.None;
        serialPort1.DataBits = 8;
        serialPort1.StopBits = StopBits.One;
        serialPort1.Handshake = Handshake.RequestToSend;
        serialPort1.DtrEnable = true;
        serialPort1.RtsEnable = true;
        serialPort1.NewLine = System.Environment.NewLine;

    }

    private void btnSend_Click(object sender, EventArgs e)
    {
        serialPort1.Open();

    }

    private void serialPort1_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
    {
        try
        {                
            string num = "+639952006630\n";
            serialPort1.Write(num);        

            string message = "Your child arrived at our school at " + DateTime.Now + ".";
            serialPort1.Write(message);                
        }
        catch (Exception ex)
        { …

我想使用mlock和将内存锁定到 C 中的物理 RAM munlock，但我不确定正确的用法。

请允许我分步解释：

让我们假设我使用动态分配一个指针calloc：

char * data = (char *)calloc(12, sizeof(char*));

我应该mlock在那之后做吗？

我们还假设我稍后尝试使用以下命令调整内存块的大小realloc：

(char *)realloc(data, 100 * sizeof(char*));

请注意，上述增加量（ 100 ）是随机的，有时我会减少内存块。

我应该先做munlock然后mlock再处理所做的更改吗？

另外，当我想data稍后释放指针时，我应该先释放指针munlock吗？

我希望有人可以向我解释正确的步骤，以便我更好地理解。

我正在尝试学习C的更高级方面，并在尝试使用__inline__关键字时编写了此代码：

#include <stdio.h>


void f(int);
void g(int);


__inline__ void f(int egg)
{
    printf("f %d\n", egg);
    g(egg);
}


__inline__ void g(int egg)
{
    printf("g %d\n", egg);
    f(egg);
}


int main()
{
    f(123);

    return 0;
}

我浏览了GNU手册，发现-Winline当标记的功能__inline__无法替代时，编译器选项会发出警告。

我确实希望gcc -ansi -pedantic -Wall -Wextra -Winline -o test test.c收到警告，但是我使用编译了该程序，但没有警告。

当我运行该程序时，它可能会由于超出了递归限制而在出现分段错误之前将数字打印了很多次。

我的问题是，gcc在这种情况下会如何表现？如果它确实内联了函​​数，怎么知道它在两个函数之间进行了递归调用？

先感谢您

以下程序：

#include <stdlib.h>

int main(void)
{
    char *my_str = malloc(42 * sizeof(char));

    return 0;
}

编译如下：

gcc -g -o prog prog.c

并用 Valgrind 执行如下：

valgrind --leak-check=full ./prog

产生以下（截断的）输出：

...
==18424== HEAP SUMMARY:
==18424==     in use at exit: 42 bytes in 1 blocks
==18424==   total heap usage: 1 allocs, 0 frees, 42 bytes allocated
==18424== 
==18424== 42 bytes in 1 blocks are definitely lost in loss record 1 of 1
==18424==    at 0x4C2FB0F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
==18424==    by 0x10865B: main (main.c:5) …

让我们看一下这个例子：

String var;
while (...) {
        var = ...
        // do stuff
}

在本例中，我们创建对对象的引用String，并在循环的每次迭代中为其分配不同的对象。

现在，在另一个例子中：

while (...) {
        String var = ...
        // do stuff
}

如果我们假设编译器很幼稚，它只会在每次迭代时String分配对堆栈上对象的引用。