Multidimensional arrays returning.

Well, actually I'm trying to create a program that receives strings from a file and replaces a few words from some kind of a source (another file) and swap between words that are in the source of the words.
These words are shown this way in the file:

Code:

---

elephant fat
mouse thin
smart stupid

---

and in the original file there are strings, such as:

Code:

---

This guy is really smart!

---

So now, I'm trying to receive the data from the strings-file and swap words that are shown in the source file and create a new sentence by swapping these words.
e.g:
original file:

Code:

---

You are smart

---

After compiling:

Code:

---

You are stupid.

---

Here's what I've got so far:

Code:

---

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

#define LENGTH 50

char *newSubstr(char *str, int index);
char **explode(char *str, char seperator);

int main(void)
{
    FILE *handle, *db;
    char *filename, str[LENGTH];
   
    printf("File: ");
    fgets(filename, 16, stdin);
   
    handle = fopen(filename, "rt");
    db = fopen("database.txt", "rt");
   
    while(fgets(str, LENGTH, handle) != NULL)
    {
                    for(int i = 0; i < strlen(str); i++)
                    {
                            if(str[i] == ' ' && i + 1 < strlen(str))
                            {
                                      char search[LENGTH], **results;
                                      while(fgets(search, LENGTH, db) != NULL)
                                      {
                                                  results = explode(search, ' ');
                                                  if(strcmp(results[0], newSubstr(str, i+1)) == 0) // if equals, swap the string with results[1]
                                                                        printf("Match! &#37;s - %s", results[0], results[1]);                                                             
                                      }
                            }
                    }                         
    }
   
 getchar();
 return 0; 
}

char *newSubstr(char *str, int index)
{
 int i = index, j= 0;
 char *newstr = "";
 
 for(; i < strlen(str); i++)
 {
      if(str[i] == ' ')
                break;
      newstr[j++] = str[i];
 }
               
 return newstr;
}


char **explode(char *str, char seperator) // explodes ONLY 2 strings that are seperated by a character
{
    int i = 0, index = 0;
    for(; i < strlen(str); i++)
          if(str[i] == seperator)
                    break;
   
    char **newexplode;
    if(i != 0 && i != strlen(str) - 1)
    {
        int index_0 = 0, index_1 = 0;
        int j = 0;
        for(; j < i; j++)
          newexplode[0][index_0++] = str[j];                         
        for(; i < strlen(str); i++)
          newexplode[1][index_1++] = str[i];                         
    }
   
    return newexplode;
}

---

I'm pretty sure (actually, I know) that there is a problem with the return values of `explode` and `newSubstr`...I dunno, look at this code for example:

Code:

---

char *newSubstr(char *str, int index)
{
 int i = index, j = 0;
 char newstr[20];
 
 for(; i < strlen(str); i++)
 {
      if(str[i] == ' ')
                break;
      newstr[j++] = str[i];
 }
               
 return newstr;
}

int main(void)
{
    char *str = newSubstr("Hello world", 6);
        printf("%s", str);
    getchar();
 return 0; 
}

---

Really basic but still, `str` contains total garbage, and I don't know why...



It's pretty basic what I've done here so please help me ASAP (these are just pointers and return values, come on :))

>>char **newexplode;
>>newexplode[0][index_0++] = str[j];
You never allocate any memory for newexplode.

It seems that you are nowhere allocating memory for the exploded strings?
And anyway, there is the strtok function that might be suitable for splitting strings.

In newSubstr you are returning a pointer to a local array. The problem with local arrays is that they go out of scope and the pointer is not valid once the function returns. (In addition newstr doesn't appear to get 0-terminated.)
Usually it is just easier to pass the buffer that receives output as an argument. Think about strcpy: it doesn't allocate any new memory, it copies to the provided buffer.

> Elysia, Why do I need to allocate memory for `newexplode`?
> anon, Why I'm supposed to 0-terminate newstr?

Quote:

---

Usually it is just easier to pass the buffer that receives output as an argument. Think about strcpy: it doesn't allocate any new memory, it copies to the provided buffer.

---

What do you mean?

Quote:

---

Originally Posted by eXeCuTeR

>
> anon, Why I'm supposed to 0-terminate newstr?

What do you mean?

---

Strings in C must be terminated with the '\0' character. This is the way how any function such as strlen or printf can actually know where the string ends.

As to how newSubstr could be implemented:

Code:

---

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

void newSubstr(char* output, const char *str, int index)
{
    int i = index, j = 0;

    /*strlen is a bit too expensive to call each time in a loop*/
    int length = strlen(str);

    for(; i < length; i++)
    {
        if(str[i] == ' ')
            break;
        output[j++] = str[i];
    }
    /*null-terminate the output string*/
    output[j] = '\0';
}

int main(void)
{
    /*declare the array that receives the substring and pass it to newSubstr*/
    char str[20];
    newSubstr(str, "Hello world", 6);
        printf("%s", str);
    getchar();
 return 0;
}

---

As to why you need to allocate memory for newexplode: if you don't make it to point to some memory, the pointer will point to random garbage and you'd end up trying to write to a random place in memory that your program might not own.

However, it is not easy to allocate (and free) two-dimensional arrays.

Instead you might simply modify the original string, taking advantage of how strings are represented in C, and return a pointer that points in the middle of the original string where the second word begins.

Code:

---

original string:
'm','o','u','s','e',' ','t','h','i','n','\0'
 ^
 |
str

after splitting:
'm','o','u','s','e','\0','t','h','i','n','\0'
 ^                        ^
 |                        |
str                    start of
                      second word

---

Quote:

---

Originally Posted by anon

Strings in C must be terminated with the '\0' character. This is the way how any function such as strlen or printf can actually know where the string ends.

As to how newSubstr could be implemented:

Code:

---

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

void newSubstr(char* output, const char *str, int index)
{
    int i = index, j = 0;

    /*strlen is a bit too expensive to call each time in a loop*/
    int length = strlen(str);

    for(; i < length; i++)
    {
        if(str[i] == ' ')
            break;
        output[j++] = str[i];
    }
    /*null-terminate the output string*/
    output[j] = '\0';
}

int main(void)
{
    /*declare the array that receives the substring and pass it to newSubstr*/
    char str[20];
    newSubstr(str, "Hello world", 6);
        printf("&#37;s", str);
    getchar();
 return 0;
}

---

---

As I've heard, C automatically 0-terminates arrays, doesn't it?
Anyways,
I've got 1 questions:
Why do local arrays go out of scope if they are returned as pointers?
As for explode...I've tried to implement it this way:

Code:

---

void explode(char *str, char seperator, char **match) // explodes ONLY 2 strings that are seperated by a character
{
    char first[20], second[20];
    int i = 0, index = 0;
    for(; i < strlen(str); i++)
          if(str[i] == seperator)
                    break;
   
    if(i != 0 && i != strlen(str) - 1)
    {
        int index_0 = 0, index_1 = 0;
        int j = 0;
        for(; j < i; j++)
          first[index_0++] = str[j];                         
        for(; i < strlen(str); i++)
          second[index_1++] = str[i];   
         
        strcpy(match[0], first);
        strcpy(match[1], second);                     
    }
}

---

But it's not working properly.
Why?

Quote:

---

Originally Posted by eXeCuTeR

As I've heard, C automatically 0-terminates arrays, doesn't it?

---

Yes, library functions do that. But if you manipulate individual characters yourself, you have to take care of terminating strings.

Quote:

---

Anyways,
I've got 1 questions:
Why do local arrays go out of scope if they are returned as pointers?

---

That's because they are local. You would be returning a pointer to something that doesn't exist after the function returns.

Quote:

---

As for explode...I've tried to implement it this way:
...snip...

But it's not working properly.
Why?

---

For one thing, you are still not terminating the new strings.

For another thing, which can't be seen from this code: have you allocated any memory for match in the calling code (and how)?

Anyway, you might take a look at my previous post to see how the same thing could be done without allocating any new strings.

Quote:

---

Originally Posted by anon

Yes, library functions do that. But if you manipulate individual characters yourself, you have to take care of terminating strings.

That's because they are local. You would be returning a pointer to something that doesn't exist after the function returns.


For one thing, you are still not terminating the new strings.

For another thing, which can't be seen from this code: have you allocated any memory for match in the calling code (and how)?

Anyway, you might take a look at my previous post to see how the same thing could be done without allocating any new strings.

---

Oh right, forgot to 0-terminate.
---
I haven't allocated any memory to any array, I have just called it this way, which seems totally cool for me:

Code:

---

    char *newarr[2];
    explode("Hello world", ' ', newarr);
    printf("%s [ ~ ] %s", newarr[0], newarr[1]);

---

I would like to hear the way to do this by allocating memory and the other way.

It may look cool to you but it is still nothing more than an array of two pointers to garbage.

It should look something like this:

Code:

---

int main()
{
    char *newarr[2];
    newarr[0] = malloc(20);
    newarr[1] = malloc(20);
    explode("Hello world", ' ', newarr);
    printf("%s [ ~ ] %s", newarr[0], newarr[1]);
    free(newarr[0]);
    free(newarr[1]);
    return 0;
}

---

However, if you just modified the original string in place (as my ASCII art shows) it might be implemented like this (you can roll your own if you are not allowed to use library functions).

Code:

---

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

char* explode(char* str, const char* separator)
{
    char* second = strtok(str, separator);
    if (second != NULL) {
        second = strtok(NULL, separator);
    }
    return second;
}

int main()
{
    char str[] = "Hello world";
    char* second = explode(str, " ");
    printf("%s [ ~ ] %s", str, second);
    return 0;
}

---

It works good now with the memory allocation.
Why can't I do this thing:

Code:

---

char *arr[2] = (char *)malloc(40);

---

I should allocate memory to each pointers(or ARRAYS) I use (in case he is not pointing to any variable)? I'm assuming that yes since pointers that are not initialized point to a random memory address.

If anyone is interested...

Code:

---

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

#define LENGTH 80

void explode(char *str, char seperator, char **match, int index1, int index2) // explodes ONLY 2 words that are seperated by a character
{
    int i = 0, index = 0;
    for(; i < strlen(str); i++)
          if(str[i] == seperator)
                    break;
   
        int index_1 = 0, index_2 = 0;
        int j = 0;
        for(; j < i; j++)
          match[index1][index_1++] = str[j]; 
        i++;                       
        for(; i < strlen(str); i++)
        {
          if(str[i] == '\n')
                    break;
          match[index2][index_2++] = str[i];
        }
             
        match[index1][index_1] = '\0';
        match[index2][index_2] = '\0';                   
}

void newSubstr(char* output, char *str, int index)
{
    int i = index, j = 0;

    /*strlen is a bit too expensive to call each time in a loop*/
    int length = strlen(str);

    for(; i < length; i++)
    {
        if(str[i] == ' ' || str[i] == '\n')
            break;
        output[j++] = str[i];
    }
    /*null-terminate the output string*/
    output[j] = '\0';
}

int main(void)
{
    FILE *handle, *db;
    handle = fopen("hi.txt", "r");
    db = fopen("database.txt", "r");
   
    int len = 0;
    char newDBstring[LENGTH], *results[LENGTH/2], str[LENGTH];
   
    for(int i = 0; i < LENGTH/2; i++)
            results[i] = (char *)malloc(LENGTH/2);
           
    int index1 = 0, index2 = 1;
    while(fgets(newDBstring, LENGTH, db) != NULL)
    {
                            explode(newDBstring, ' ', results, index1, index2);
                            printf("&#37;s,%s\n", results[index1], results[index2]);
                            index1 = index1 + 2, index2 = index2 + 2;
                            len++;
    }
   
    while(fgets(str, 40, handle) != NULL)
    {
                    printf("\n%s\n", str);
                    for(int i = 0; i < strlen(str); i++)
                    {
                            if(str[i] == ' ' || i == 0)
                            {
                                      int index = 0;
                                      char *output = (char *)malloc(LENGTH);
                                      if(i == 0)
                                            newSubstr(output, str, i);
                                      else
                                          newSubstr(output, str, i+1);
                                      printf("Output: %s\n", output);
                                      for(int k = 0; k < len*2; k = k+2)
                                      {
                                              if(strcmp(output, results[k]) == 0)
                                                                    printf("MATCH! %s = %s -> %s\n", output, results[k], results[k+1]);       
                                      }
                                      free(output);
                            }       
                    }               
    }
    fclose(handle);
    fclose(db);
    for(int i = 0; i < len; i++)
            free(results[i]);
   
    getchar(); 
    return 0;
}

---

The Output for your program is

Code:

---

smart,hard
pass,fail

You are smart

Output:You
Output:are
Output:smart
MATCH! smart = smart -> hard

---

Is this is the same output which is as per design.

I thought you must get like

If it is

Code:

---

You are smart

---

Code:

---

You are stupid

---

where database.txt is

Code:

---

smart stupid

---

and hi.txt is

Code:

---

You are smart

---

Quote:

---

Originally Posted by eXeCuTeR

It works good now with the memory allocation.
Why can't I do this thing:

Code:

---

char *arr[2] = (char *)malloc(40);

---

I should allocate memory to each pointers(or ARRAYS) I use (in case he is not pointing to any variable)? I'm assuming that yes since pointers that are not initialized point to a random memory address.

---

I think you would write it like:

Code:

---

char (*arr)[2] = (char (*)[10])malloc(40);

---

so you typecast in an appropriate thing. The other will not work, since *arr[2] isn't type of char*

Code:

---

char (*arr)[2] = (char (*)[10])malloc(40);

---

I get an "initialization from incompatible pointer type" warning. And when I try it, it indeed doesn't do what I want.

Since it is an array of 2 pointers, I believe you can't get away without two memory allocations (or assigning two pointers):

Code:

---

char* arr[2] = {malloc(20), malloc(20)};

---

Code:

---

const char* str = "Hello\0world";
const char* arr[2] = { str, str + 6 };

---

People, don't cast the return of malloc.
If you assign a valid pointer from malloc to your pointer, you will not get a warning. If you do, however, you WILL get a warning, that tells you that you did wrong.
If you cast the return, you will NOT get a warning that says you did something wrong, so do not cast malloc.

Quote:

---

Originally Posted by vlrk

The Output for your program is

Code:

---

smart,hard
pass,fail

You are smart

Output:You
Output:are
Output:smart
MATCH! smart = smart -> hard

---

Is this is the same output which is as per design.

I thought you must get like

If it is

Code:

---

You are smart

---

Code:

---

You are stupid

---

where database.txt is

Code:

---

smart stupid

---

and hi.txt is

Code:

---

You are smart

---

---

It wouldn't be hard enough to write to the file.

> anon, I've got 2 questions:
Say that I have a string:
char *str = "Hello world";
Am I supposed to null-terminate this string? you haven't done it in your code..

Could you answer my former questions?

Quote:

---

I should allocate memory to each pointers I use (in case he is not pointing to any variable)? I'm assuming that yes since pointers that are not initialized point to a random memory address.
And what about arrays...should I allocate memory for them or they are automatically allocated in the stack by the compiler?

---

> Elysia, what's your point?

Quote:

---

Originally Posted by eXeCuTeR

Say that I have a string:
char *str = "Hello world";
Am I supposed to null-terminate this string? you haven't done it in your code..

---

It's automatically null terminated, but it should be const char*.

Quote:

---

Originally Posted by Elysia

It's automatically null terminated, but it should be const char*.

---

What about char * and why specifically const char *?
In case of this very simple program:

Code:

---

char *name = (char *)malloc(20);
*name = "Hello"; // is this even legal?
*(name + 6) = "\0"; // should I do this?

---

Please answer my previous questions too, thanks.

Um, no that's not legal. Use strcpy().

Your code is illegal. Again, do not cast the return of malloc.
Better code would be:

Code:

---

char *name = malloc(20);
strcpy(name, "Hello");

---

Quote:

---

Originally Posted by Elysia

Your code is illegal. Again, do not cast the return of malloc.
Better code would be:

Code:

---

char *name = (char *)malloc(20);
strcpy(name, "Hello");

---

---

Why is my code illegal, what's wrong with it?
About the return-casting...you are telling me not to cast the return value of malloc but you are casting it yourself...am I missing something?

Quote:

---

Originally Posted by eXeCuTeR

Why is my code illegal, what's wrong with it?

---

Because a string literal is const char*. You are trying to assign a pointer in your buffer, which is not the same as copying the data.

Quote:

---

About the return-casting...you are telling me not to cast the return value of malloc but you are casting it yourself...am I missing something?

---

Sorry, I just copied your code and forgot to remove it. I fixed it.
(Note that if you are using C++ to compile the code, you need the cast, but if you are compiling it as C, no cast is necessary.)

About null-terminating:
most if not all standard library string functions null-terminate the string (and expect a null-terminated string).
Literal strings are null terminated by the compiler:

Code:

---

const char* str1 = "Hello";
//str1 points to a non-modifiable null-terminated string
char str2[] = "world";
//str2 points to a modifiable null-terminated string

---

But if you manipulate the individual characters yourself, naturally you must null-terminate the string. E.g

Code:

---

char str[10];
str[0] = 'a';
str[1] = 'b';
str[2] = 'c';

/*str[3] does not necessarily contain '\0' here, since str initially contains uninitialized garbage*/
/*hence:*/
str[3] = '\0';

---

Or you can initialize the buffer to all '\0'-s to begin with, in which case str[3] would also contain '\0':

Code:

---

char str[10] = {};

---

Code:

---

char str[10] = {};

---

Would initialize all of the cells in str to \0?
---
Why does this code work?

Code:

---

char *str = malloc(20);
str = "Hello world"; // how come this works?
printf("%s", str);

---

How come the 2nd line works? Shouldn't I add '*' before str to access its value and not its address?

One more thing..
Assuming I have a pointer that points to the stack: what does &p contain? I mean, p holds the address, and *p holds the value, what else could &p hold? (it's a pointer to a pointer, right?)

Code:

---

int hi = 5;
int *p = &hi;

---

BTW, what's %i?

Quote:

---

Originally Posted by eXeCuTeR

Code:

---

char str[10] = {};

---

Would initialize all of the cells in str to \0?

---

Yes, all elements are initialized to 0.

Quote:

---

Why does this code work?

Code:

---

char *str = malloc(20);
str = "Hello world"; // how come this works?
printf("%s", str);

---

How come the 2nd line works? Shouldn't I add '*' before str to access its value and not its address?

---

This code is flawed and bad.

A string literal, such as "Hello world" is a pointer to const char (const char*).
Typically, the compiler will store that string somewhere inside the EXE and when you try to assign it somewhere, it fetches that address and stuffs it into a pointer.
So what happens in your example above?
Also remember that dereferencing a pointer gives you the value. However, an array is values (many, not single). Therefore, you will get only ONE value, and not the entire.
In other words, dereferencing char*, will give you char, not a string. What happens then?
sizeof(char*) is probably 4 and sizeof(char) is 1, so in that sense, even there you are doing something fatefully wrong.

Quote:

---

One more thing..
Assuming I have a pointer that points to the stack: what does &p contain? I mean, p holds the address, and *p holds the value, what else could &p hold?

Code:

---

int hi = 5;
int *p = &hi;

---

---

&p is the address of the pointer, simply put. A pointer is still a variable and thus has an address. The resulting type would be int** (a pointer to int*).

Quote:

---

Originally Posted by eXeCuTeR

Why does this code work?

Code:

---

char *str = malloc(20);
str = "Hello world"; // how come this works?
printf("%s", str);

---

How come the 2nd line works? Shouldn't I add '*' before str to access its value and not its address?

---

What happens in this code:
1) 20 char's are allocated and str is a pointer to this memory
2) Second line makes str point to a unmodifiable literal string instead. Previously allocated memory is leaked: you don't have a pointer to it anymore, meaning your program cannot use this memory and cannot deallocate it either.

Strings and literal characters (static strings etc') are located in a "special" place and don't have an address, this is the point, right?

If so..

Code:

---

char *name = malloc(20);
fgets(name, 20, stdin);

---

This is not considered literal and should be constant?

Quote:

---

Originally Posted by eXeCuTeR

Strings and literal characters (static strings etc') are located in a "special" place and don't have an address, this is the point, right?

---

String literals only, but they DO have an address.
Without it, it would be unusable.
The point is that the compiler can store the literals there and point to them instead of creating code to create these strings everytime you use them.
That is the point.

Quote:

---

If so..

Code:

---

char *name = malloc(20);
fgets(name, 20, stdin);

---

---

String literals are non-modifiable and should therefore be const to make sure you don't modify them.
But if you apply const to name here, what would happen? You can't modify the data you allocated, thus defying the point of doing it in the first place.

Quote:

---

Originally Posted by Elysia

String literals only, but they DO have an address.
Without it, it would be unusable.
The point is that the compiler can store the literals there and point to them instead of creating code to create these strings everytime you use them.
That is the point.


String literals are non-modifiable and should therefore be const to make sure you don't modify them.
But if you apply const to name here, what would happen? You can't modify the data you allocated, thus defying the point of doing it in the first place.

---

How do I check theirs addresses?

They are pointers! How else?

Like this?

Code:

---

#include <stdio.h>

int main(void)
{
    printf("0x&#37;p\n", "Hello world");
    printf("0x%p\n", "There!");
    return 0;
}

---

EDIT: Thanks guys, if I'll have other questions I'll ask.

Quote:

---

Code:

---

const char *str = "Hello world!";
printf("%s", str); // output: Hello World and not str's address.

---

I'm pretty sure that constant strings are located in a static location in the stack and don't have an address.

---

I hope you understand that the above code prints the contents of the string and not its address. It's the same as for any pointer. Use %p to print the address, and use %s to print the contents of a string.