Strcat си ошибка сегментирования

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

void main(int arge, char *argv[])
{
    FILE *f1;
    char ch,*fn="~/lyrics/";
    strcat(fn,argv[1]);
    strcat(fn,".txt");
    if( (f1 = fopen(fn,"r"))==NULL )
    {
        printf("nWrong filenamen%s not found",argv[1]);
        return;
    }
    while((ch=getw(f1))!=EOF)
    {
        printf("%c",ch);
    }
}

Segmentation fault (core dumped)
Bad permissions for mapped region at address 0x8048659 at 0x402C36B: strcat 
(in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so) by 0x80484D6: main (lyrics.c:9)

5

Недавно я начал работать над изучением языка Си и неоднократно сталкивался с ошибкой, при которой вызов функции strcat из модуля <string.h> приводит к ошибке сегментации. Я искал ответы в Интернете, в том числе в этом сообщении stackoverflow, но безуспешно. Я думал, что у этого сообщества может быть более личное понимание проблемы, поскольку общие решения, похоже, не работают. Может быть ошибка пользователя, может быть личная проблема с кодом. Взглянуть.

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

char * deblank(const char str[]){
    char *new[strlen(str)];
    char *buffer = malloc(strlen(new)+1);
    for (int i=0; i<strlen(*str); i++){
        if(buffer!=NULL){
            if(str[i]!=" "){
                strcat(new,str[i]); //Segmentation fault
            }
        }
    }
    free(buffer);
    return new;
}

int main(void){
    char str[] = "This has spaces in it.";
    char new[strlen(str)];
    *new = deblank(str);
    puts(new);
}

Я разместил комментарий в строке, в которой проследил ошибку сегментации. Ниже приведен пример использования Java-кода в этом C-коде.

public class deblank {
    public static void main(String[]args){
        String str = "This has space in it.";
        System.out.println(removeBlanks(str));
    }

    public static String removeBlanks(String str){
        String updated = "";
        for(int i=0; i<str.length(); i++){
            if(str.charAt(i)!=' '){
                updated+=str.charAt(i);
            }
        }
        return updated;
    }
}

Любое понимание этой ошибки будет высоко ценится. Пожалуйста, укажите также опечатки … Я был известен, чтобы сделать их. Спасибо.

Вы не можете использовать strcat так, как вы это делали, оно предназначено для преобразования C-строки в конец другой данной строки. str[i] является символом, а не C-строкой (помните, что C-строка представляет собой непрерывную последовательность символов, последним из которых является байт NUL).

Вы также не можете сравнивать строки со стандартными операторами сравнения, если вам действительно нужно сравнивать строки, то для этого есть функция strcmp. Но вы можете сравнивать символы со стандартными операторами, так как char — это просто целочисленный тип.

Это должно сделать трюк:

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

char * deblank(const char str[]) {
    char *buffer = malloc(strlen(str)+1); // allocate space to contains as much char as in str, included ending NUL byte
    for (int i=0, j=0; i<strlen(str)+1; i++) { // for every char in str, included the ending NUL byte
      if (str[i]!=' ') { // if not blank
        buffer[j++] = str[i]; // copy
      }
    }
    return buffer; // return a newly constructed C-string
}

int main(void){
    char str[] = "This has spaces in it.";
    char *new = deblank(str);
    puts(new);
    free(new); // release the allocated memory
}

Вы можете попробовать рекурсивно

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

void deblank(const char* str, char *dest) {
    if (!*str) {*dest = '';return;}

    // when we encounter a space we skip
    if (*str == ' ') {
      deblank(str+1, dest);
      return;
    }

    *dest = *str;
    deblank(str+1, dest+1);
}

int main(void) {
    const char *str = "This has spaces in it.";
    char *output    = malloc(strlen(str)+1);
    deblank(str, output);
    puts(output);
    free(output);
}

Там может быть три подхода к задаче.

Первый — обновить строку «на месте». В этом случае функция может выглядеть примерно так

#include <stdio.h>
#include <ctype.h>
#include <iso646.h>

char * deblank( char s[] )
{
    size_t i = 0;

    while ( s[i] and not isblank( s[i] ) ) ++i;

    if ( s[i] )
    {
        size_t j = i++;
        do
        {
            if ( not isblank( s[i] ) ) s[j++] = s[i];
        } while( s[i++] );
    }

    return s;
}

int main(void) 
{
    char s[] = "This has spaces in it.";

    puts( s );

    puts( deblank( s ) );

    return 0;
}

Выход программы

This has spaces in it.
Thishasspacesinit.

Другой подход заключается в копировании исходной строки в массиве символов назначения, пропуская пробелы.

В этом случае функция будет иметь два параметра: исходный массив и целевой массив. И размер массива назначения должен быть равен размеру исходного массива, потому что в общем случае исходный массив не может иметь пробелов.

#include <stdio.h>
#include <ctype.h>
#include <iso646.h>

char * deblank( char *s1, const char *s2 )
{
    char *t = s1;

    do 
    {
        if ( not isblank( *s2 ) ) *t++ = *s2;
    } while ( *s2++ );

    return s1;
}

int main(void) 
{
    char s1[] = "This has spaces in it.";
    char s2[sizeof( s1 )];

    puts( s1 );

    puts( deblank( s2, s1 ) );

    return 0;
}

Вывод программы будет таким же, как показано выше.

Обратите внимание на эту декларацию

char s2[sizeof( s1 )];

Размер строки назначения в целом должен быть не меньше, чем размер исходной строки.

И, наконец, третий подход — когда внутри функции динамически создается массив, и из функции возвращается указатель на первый элемент массива.

В этом случае желательно сначала подсчитать количество пробелов в исходном массиве, чтобы выделить массив назначения с соответствующим размером.

Чтобы использовать функции malloc и free, вам необходимо включить следующий заголовок

#include <stdlib.h>

Функция может быть реализована так, как показано в демонстрационной программе.

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


char * deblank( const char *s )
{
    size_t n = 1;   /* one byte reserved for the terminating zero character */

    for ( const char *t = s; *t; ++t )
    {
        if ( not isblank( *t ) ) ++n;
    }

    char *s2 = malloc( n );

    if ( s2 != NULL )
    {
        char *t = s2;       
        do 
        {
            if ( not isblank( *s ) ) *t++ = *s;
        } while ( *s++ );
    }

    return s2;
}

int main(void) 
{
    char s1[] = "This has spaces in it.";
    char *s2 = deblank( s1 );

    puts( s1 );
    if ( s2 ) puts( s2 );

    free( s2 );

    return 0;
}

Вывод программы такой же, как и для двух предыдущих программ.

Что касается стандартной функции C strcat, то она содержит две строки.

Например

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

int main(void) 
{
    char s1[12] = "Hello ";
    char *s2 = "World";

    puts( strcat( s1, s2 ) );

    return 0;
}

Массив назначения (в данном случае s1) должен иметь достаточно места для добавления строки.

В Стандарте C есть еще одна функция C strncat, которая позволяет добавлять в строку один символ. Например, вышеприведенную программу можно переписать следующим образом

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

int main(void) 
{
    char s1[12] = "Hello ";
    char *s2 = "World";

    for ( size_t i = 0; s2[i] != ''; i++ )
    {
        strncat( s1, &s2[i], 1 );
    }

    puts( s1 );

    return 0;
}

Но неэффективно использовать такой подход для вашей исходной задачи, потому что каждый раз, когда вызывается функция, она должна найти конечный ноль в исходной строке, чтобы добавить символ.

Я попытался скомпилировать с включенными предупреждениями, вот некоторые, которые вы должны исправить.

• Вы должны включить stdlib.h
• char *new[strlen(str)] создает массив char*, а не char, поэтому на самом деле это не строка. Измените его на char new[strlen(str)].
• Чтобы проверить, является ли str[i] пробелом, вы сравниваете его с пробелом ' ', а не с строкой, единственным символом которой является пробел " ". Так что измените его на str[i]!=' '
• strcat принимает строку в качестве второго аргумента, а не символ, как вы передаете ее с помощью str[i].

Кроме того, для чего вы используете buffer?

Другая ошибка заключается в том, что вы, вероятно, предполагали, что неинициализированные массивы принимают нулевые значения. Массив new имеет случайные значения, а не ноль / ноль. strcat объединяет две строки, поэтому он попытается поместить строку в свой второй аргумент в конце первого аргумента new. «Конец» строки является нулевым символом. Программа ищет new первого нулевого символа, который может найти, и когда она находит этот нулевой символ, она начинает записывать второй аргумент оттуда.

Но поскольку new неинициализирован, программа может не найти нулевой символ в new и будет продолжать поиск дальше, чем длина new, strlen(str), продолжая поиск в нераспределенной памяти. Это, вероятно, то, что вызывает ошибку сегментации.

ОК, давай сделаем это.

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

char * deblank(const char str[]){
    char *new[strlen(str)];

^ Эта строка создает массив указателей, а не строку.

    char *buffer = malloc(strlen(new)+1);

malloc не объявлен. Отсутствует #include <stdlib.h>. Кроме того, вы должны проверить наличие ошибки распределения здесь.

strlen(new) — ошибка типа. strlen занимает char *, но new является (или, скорее, оценивает) как char **.

    for (int i=0; i<strlen(*str); i++){

strlen(*str) — ошибка типа. strlen занимает char *, но *str является char (то есть одним символом).

i<strlen(...) сомнителен. strlen возвращает size_t (тип без знака), тогда как i является int (со знаком и, возможно, слишком маленьким).

Вызов strlen в цикле неэффективен, потому что он должен пройти всю строку, чтобы найти конец.

        if(buffer!=NULL){

Это странное место для проверки на отсутствие выделения. Кроме того, вы нигде не используете buffer, так зачем вообще его создавать / проверять?

            if(str[i]!=" "){

str[i]!=" " — ошибка типа. str[i] является char, тогда как " " является (или, скорее, оценивает) как char *.

                strcat(new,str[i]); //Segmentation fault

Это ошибка типа. strcat занимает две строки (char *), но new является char **, а str[i] является char. Кроме того, первый аргумент strcat должен быть допустимой строкой, но new неинициализирован.

            }
        }
    }
    free(buffer);
    return new;

new является локальным массивом в этой функции. Вы возвращаете адрес его первого элемента, что не имеет смысла: как только функция вернется, все ее локальные переменные исчезнут. Вы возвращаете неверный указатель здесь.

Кроме того, это ошибка типа: объявлено, что deblank возвращает char *, но фактически возвращает char **.

}

int main(void){
    char str[] = "This has spaces in it.";
    char new[strlen(str)];
    *new = deblank(str);

Это ошибка типа: *new является char, но deblank возвращает char *.

    puts(new);

puts принимает строку, но new по сути является мусором на этом этапе.

}

Итак, не уверен, поможет ли это вам, но код C, выполняющий то же самое, что и код Java, будет выглядеть так:

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

static char *removeBlanks(const char *str)
{
    char *result = malloc(strlen(str) + 1);
    if (!result) exit(1);
    const char *r = str;
    char *w = result;
    while (*r)
    {
        // copy each character except when it's a blank
        if (*r != ' ') *w++ = *r;
        ++r;
    }
    *w = 0; // terminate the result to be a string (0 byte)
    return result;
}

int main(void)
{
    const char *str = "This has spaces in it.";
    char *new = removeBlanks(str);
    puts(new);
    free(new);
    return 0;
}

Я бы не рекомендовал называть переменную new … если вы когда-нибудь захотите использовать C ++, это зарезервированное ключевое слово.

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

int main() {
    char first[7] = "first";
    char second[7] = "second";
    char *third = strcat(first, second);
}

→ Ссылка

Автор решения: zed

    char* concat(char *s1, char *s2) {

        size_t len1 = strlen(s1);
        size_t len2 = strlen(s2);                      

        char *result = malloc(len1 + len2 + 1);

        if (!result) {
            fprintf(stderr, "malloc() failed: insufficient memory!n");
            return NULL;
        }

        memcpy(result, s1, len1);
        memcpy(result + len1, s2, len2 + 1);    

        return result;
    }

    char *s = concat("first", "second");
    printf("%sn", s);
    free(s);

→ Ссылка

Автор решения: αλεχολυτ

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

int main() {
    const char* first = "first"; // const явно указывает, что такие данные менять нельзя
    const char* second = "second";
    char* buff = calloc(strlen(first) + strlen(second) + 1, 1);
    strcat(buff, first);
    strcat(buff, second);
    printf("%sn", buff);
    free(buff);
}

→ Ссылка

Автор решения: insolor

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

int main() {
    char first[256] = "first";
    char second[] = "second";
    strcat(first, second);
    puts(first);
    return 0;
}

→ Ссылка

Автор решения: AnT

#define FIRST  "first"
#define SECOND "second"

int main(void) 
{
    const char *first  = FIRST;
    const char *second = SECOND;
    const char *third  = FIRST SECOND;
}

#include <stdio.h>

int main(void) 
{
    const char *first  = "first";
    const char *second = "second";

    char third[512];
    snprintf(third, sizeof third, "%s%s", first, second);
}

→ Ссылка

Автор решения: avp

#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

int 
main (int ac, char *av[])
{
  char first[] = "first", 
    second[] = "second";
  char *third;

  if (asprintf(&third, "%s%s", first, second) < 0)
    third = strdup(strerror(errno));

  return puts(third) == EOF;
}

static int 
asprintf (char **ps, const char *fmt, ...)
{
  //   puts("my asprintf");
  va_list ap;
  va_start(ap, fmt);
  int rc = vsnprintf(*ps, 0, fmt, ap);
  va_end(ap);
  if (rc >= 0) {
    if ((*ps = (char *)malloc(rc + 2))) {
      va_start(ap, fmt);
      rc = vsnprintf(*ps, rc + 1, fmt, ap);
      va_end(ap);
    } else
      rc = -1;
  }

  return rc;
}

→ Ссылка

Автор решения: Daniel Shatz

#include <stdlib.h>
#include <string.h>

char* concat(char *s1, char *s2)
{
    char *result = malloc(strlen(s1)+strlen(s2)+1);//+1 нужен для нуль-терминатора строки.
    strcpy(result, s1);
    strcat(result, s2);
    return result;
}

→ Ссылка

Автор решения: MarianD

→ Ссылка

Полезно ли: