Thread: Malloc is it me or Malloc? ( or me ) How to...

I had this working, but it was only inserting one word into a string at given length using scanf.

scanf only gets one word at a time. To eliminate that only one word limit unknown words wanted to be added to line thing. I replaced scanf with getline.

now I am having problems getting a new char length of line1 + line2 + 1 using the method I used then went to malloc and still am getting a 0 (zero) on length using malloc to further modify the code to add more than one word into a string at given position.

( some comments in code to explaine as well )

Code:

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

char * insertString(char* destination, int pos, char* sub_string)
{
    printf("Destanation %s\n", destination);
    
    // gets 45 length
    printf("\nstrlen Destanation %lu\n\n", strlen(destination) );
    // gets whatever lenght input is
    printf("\nstrlen sub_string %lu\n\n", strlen(sub_string) );
    
    // add the two together plus one for \0
   // char HoldStr1[ (strlen(destination))+(strlen(sub_string))+1 ];
    
    //add the two together plus 1
    // gets 6
    printf("\n\nstrlen HoldStr1 %lu\n\n", strlen(HoldStr1) );
    
    //do it this way 
     
    int size_of_string = (strlen(destination))+(strlen(sub_string))+1;

    // gets 58 which = dest len + whatever input len is + 1
    printf("size of string %d\n",size_of_string );
    
    // do it this way gets zero lenght
    //char *HoldStr = (char *)malloc(size_of_string * sizeof(char));
    
    
    // do it this way size_of_string = 58
    char *HoldStr;
    HoldStr = (char *)malloc(size_of_string);
    //gets zero
    printf("\nstrlen HoldStr  %lu\n\n", strlen(HoldStr) );
    

// cannot go any further until above is fixed. 
// it now just returns the sub_string input as output 
// like this

    strncpy(HoldStr,destination,pos);
    
    printf("1. HoldStr %s\n",HoldStr);
    
    HoldStr[pos] = '\0';
    
    strcat(HoldStr,sub_string);
    
    printf("2. HoldStr %s\n",HoldStr);
    
    strcat(HoldStr,destination+pos);
    
    printf("3. HoldStr %s\n",HoldStr);
    
    char *return_new_string;
    
    return_new_string = (char *)malloc(strlen(HoldStr)+1);
    
    strcpy(return_new_string,HoldStr);
    
return return_new_string;    
    
}


int main (void)
{

char *string1 = "This is base string to insert something into.";
//char string1[51];
size_t buffer_size = 51;
size_t charsAre;
char *string2;
//int ch;
int insert = 0;

string2 = (char *)malloc(buffer_size * sizeof(char));
if ( string2 == NULL)
{
    printf("Can't get buffer\n");
    exit(1);
}
printf("IN MAIN: StrLen %lu\n", strlen(string1) );

//    printf("Enter your first string. No more than 50 chars long\n");

    //scanf("%s", string1);
    
    printf("enter a short string 50 max length,\nand a number where to put it too\n");
    
//    ch = getchar(); // to try to stop scanf from skipping

    //scanf("%s %d", string2, &insert);
    
    charsAre =  getline(&string2, &buffer_size, stdin);
    
    printf("input charsAre %zu\n", charsAre);
    
    printf("IN MAIN str2: StrLen %lu\n", strlen(string2) );
    
    printf("String2 = %s\n", string2);
    
    //output    
    char *retur = insertString(string1, insert, string2);
    printf("Returned String: main: %s \n",  retur);
    
return 0;    
}

if I go back to using just scanf it works just fine like that, but only one word again.

I didn't start looking at strlen until after I started trying to expand on only one word inserts. So I must be missing something.

Code:

destination string 
This is base string to insert something into.

input string
hello you 5

output
Returned String: main: This ihellos base string to insert something into. 

Originally Posted by jimblumberg

If you used the proper format specifier scanf() can safely retrieve multiple word strings, you may want to read the documentation for this function to see how, and also never use scanf() to retrieve a string without specifying the proper limiting width to the format specifier.


Is there a reason you chose the non-C-standard getline() instead of using fgets() which is a standard C function?

Do you know that getline() can allocate the required memory for you if you pass the correct parameters. And don't forget to free what you malloc.

Also casting the return value from malloc() is considered a bad practice in C.

Be careful with strcpy() and strcat() and the like, you need to make sure the destination array is large enough to hold the new strings.

wow almost 7 minutes to get in here to reply after clicking reply.
ok my getting strings input and manipulation with files and sdtin / stdout are not
something I do in C programming. BASH ok but C I do a different type of Programming. I blame this sight as the cause of now learning how to deal with
opening files and manipulating them. Not that it's a bad thing. I'm still getting
use to it with familiarizing myself with all of the string functions. too many, they
need to get rid of some more. my option.

getline I just became familiar with it, I am Linux OS, so maybe that is why getline.
scanf "specifying the proper limiting width to the format specifier."

oh that now rings a bell, I've been using it to get one input at a time.

I've been doing this with it.

Code:

scanf("%s %d %s", string1, int, string2);

type methodology. So I told my brain, I need the whole line, getline was the first thing that popped into my brain, so I switch it to getline. Let me to piddle with the other two now. thanks.

Be careful with strcpy() and strcat() and the like, you need to make sure the destination array is large enough to hold the new strings

hence the malloc and the char var [strlen(dest) + strlen(sub_string) + 1 ];
to get the proper size to strcat and strcpy

PS yeah, freeing malloc that last one is a no go as far as I can see.

Code:

char *return_new_string;
    
    return_new_string = (char *)malloc(strlen(HoldStr)+1);
    
    strcpy(return_new_string,HoldStr);
    
return return_new_string;

if I free it before returning it what happens? cannot free it after return, because it has already left the function, cannot free it in main because it is a local var.

program ends it gets freed. Nature of the beast.
got a better Idea?

> HoldStr = (char *)malloc(size_of_string);
> //gets zero
> printf("\nstrlen HoldStr %lu\n\n", strlen(HoldStr) );
That's because conceptually at least, the memory returned by malloc is uninitialised.
In your case, you got lucky and found a \0 in the first byte.
It could have roamed through memory until the OS decided to kill the program with a segfault.

This is how strlen works.
It's the wrong way to find the length of allocated memory.

, anything after a return statement is never executed.

What makes you think you should free "return_new_string"? Where, in main, is a variable with that name even defined?

Look at your function call:
Code:

?

1	char *retur = insertString(string1, insert, string2);

that's what I was thinking a'bout takin' a' bout.
but I'm redoing everything so I don't think that will even be there anymore.