0

我正在使用我编写的用于处理数据库输入的 tcp 服务器。我有一个位于服务器上的 tcp 客户端，它将文件名发送到位于不同 linux 服务器上的 tcp 服务器。一旦接收到文件名，linux服务器就会进入一个共享文件夹并拉取文件，然后将其插入数据库。

我的问题是正确声明缓冲区并清除它以确保我得到正确的文件名，而没有添加任何乱码或从中删除任何内容。

现在它的工作方式是这样的：

 char data[1024];

这很好，但它不会自动完全删除缓冲区，所以我尝试将内存隐式分配给“数据”，例如：

char *data = (char*) malloc(1024 * sizeof(char));
...
free(data);

或者

char *data = new char[1024]; 
...
delete[] data;

出于某种原因，上述两个声明声明了一个大小为 = 8 的缓冲区，我使用了这个 

sizeof(data);

我收到的也只有 8 个字符长。我不确定它为什么会这样做，有什么帮助吗？

编辑

char *data = (char*)malloc(1048 * sizeof(char));
if(data==NULL) exit(1);
cout << "DATA Size: " << sizeof(data) << "\n";
int msglen = read(conn, data, sizeof(data));
cout << "Server got " << msglen << " byte message: " << data << "\n";

if(write(conn, &msglen, sizeof(msglen))<0){
    cout << "Failed to write back to the client " << strerror(errno);
}

free(data);
close(conn);
4

3 回答 3

1

您的代码有几处问题。1）不要使用 malloc - 您将问题标记为 c++ - 仅在必要时使用 malloc 将其替换为：

const int dataSize = 1024;
char *data = new char[dataSize];

2) sizeof(data) 当数据为 char* 时返回 8，因为当您将数据声明为数组时，它返回指针的大小而不是数组 sizeof 将返回整个数组占用的字节。您应该将您阅读的内容替换为：

int msglen = read(conn,data,dataSize)

3）我假设你想把你刚刚收到的数据写回发送者。然后：
在写函数中，你把 sizeof(msglen) 作为第三个参数，它（大部分）总是返回 4. 删除 sizeof()。 

write(conn, data, msglen);

完成数据后，不要忘记使用以下命令清除内存： 

delete[] data;

当您使用.delete[] 分配内存时，请始终使用new[]。

于 2013-09-16T17:44:57.543 回答
1

应用程序接口write(int socket, char *buf, int len)；

代码变成了这样：

write(con, data, msglen);
于 2013-09-16T17:45:39.307 回答
0

Assuming you can't use the stack (e.g. char buf[1024]), using naked pointers is discouraged as bad style and bug prone. Instead, use RAII and some variant of amanged memory, such as shared_ptr or unique_ptr.

#include <memory> and use a std::shared_ptr<>, or std::unique_ptr<> plus std::move() to return the buffer:

std::size_t bufSize = 1024;
std::unique_ptr<char[]> myUniqueBuf(new char[bufSize]);
ssize_t msglen = ::read(conn, *myUniqueBuf, bufSize); // return type is ssize_t, not int
return std::move(myUniqueBuf); // If you need to return the buffer

// I think you will probably prefer a shared_ptr<> because it has a copy
// constructor which makes it easier to pass around and return from functions
std::shared_ptr<char[]> mySharedBuf(new char[1024]);
ssize_t msglen = ::read(conn, *mySharedBuf, bufSize); // return type is ssize_t, not int
ssize_t bytesOut = ::write(conn, *mySharedBuf, msglen);
return mySharedBuf;

The advantage to std::shared_ptr or std::unique_ptr is that you don't have to worry about cleaning up a naked pointer (i.e. calling delete[] data;) because with managed memory it will happen automatically for you when the buffer handle goes out of scope or the reference count goes to zero (e.g. myUniqueBuf or mySharedBuf).

于 2013-09-17T07:19:13.147 回答