Ubuntu编译C++时strcat触发Access violation及strcpy转换问题求助

Hey there, let's work through your two issues step by step—both are common pitfalls when dealing with C-style strings, so we'll get this sorted out!

The access violation you're hitting almost always comes down to one of two problems with your temp buffer:

• temp isn't initialized to a null-terminated string: strcat works by scanning the target buffer (temp) until it finds a \0 character to start appending. If temp is uninitialized, its memory has random garbage values—so strcat might scan way past the end of your buffer looking for that \0, leading to an out-of-bounds memory access.
• temp doesn't have enough space for the data you're adding: If you're trying to append 512 characters to temp, but the buffer's size is exactly 512, you won't have room for the mandatory trailing \0 character, which also causes an overflow.

Fixes: #

First, always initialize your buffer to ensure it's null-terminated:

// Initialize temp to all null characters (the = {0} trick zeros out the entire array)
char temp[513] = {0}; // Use 513 to leave space for the trailing '\0'

If you're copying a 512-character chunk for the first time (not appending to existing content in temp), use strncpy instead of strcat—it's safer for direct copies:

// Copy up to 512 characters from test1 to temp
strncpy(temp, test1 + your_offset, 512);
// Manually add the null terminator (strncpy won't add it if the source is exactly 512 chars)
temp[512] = '\0';

If you do need to append to temp (build up a longer string), use strncat instead of strcat to limit the number of characters added—this prevents overflow:

// Append up to 512 characters from test1 to temp
strncat(temp, test1 + your_offset, 512);
// Just double-check temp's total size is large enough for all appends!

Even better: If you're just moving raw character chunks (not building a dynamic string), use memcpy—it's faster and avoids string-related assumptions:

memcpy(temp, test1 + your_offset, 512);
temp[512] = '\0'; // Still need to null-terminate if you're treating temp as a string

This error means the types you're passing to strcpy don't match what the function expects. strcpy requires two char* arguments (a writable destination buffer and a source C-style string). Common causes here:

• fileArray is an array of std::string instead of char*: std::string is a C++ class, not a raw character pointer, so strcpy can't work with it directly.
• fileArray is an array of char* but you haven't allocated memory for each element: strcpy needs a valid, writable buffer to copy into—if fileArray[i] is a null pointer or uninitialized, you'll get a type mismatch or crash.

Fixes: #

If fileArray is std::string (preferred for C++!):

Forget strcpy entirely—just use the assignment operator, which is safe and easy:

#include <string> // Make sure to include this header

std::string fileArray[10]; // Adjust size as needed
// ... after filling temp ...
fileArray[index] = temp;

If you need to use C-style char* arrays:

First, allocate memory for each element in fileArray before copying:

char* fileArray[10]; // Array of char pointers
// ... when you're ready to copy temp into fileArray[index] ...
fileArray[index] = new char[513]; // Allocate space for 512 chars + '\0'
strcpy(fileArray[index], temp);

// Don't forget to free the memory later to avoid leaks!
for (int i = 0; i < num_elements; i++) {
    delete[] fileArray[i];
}

A Quick Pro Tip for C++ #

Since you're compiling with -std=c++11, you should strongly consider using std::string for all string operations. It eliminates almost all memory management headaches (like forgotten null terminators and buffer overflows) and has built-in methods for appending, copying, and splitting strings.

内容的提问来源于stack exchange，提问作者tammy2442