Ok a few things: gets is unsafe and should be replaced with fgets(input, sizeof(input), stdin) so that you don't get a buffer overflow.

Next, to compare strings, you must use strcmp, where a return value of 0 indicates that the two strings match. Using the equality operators (ie. !=) compares the address of the two strings, as opposed to the individual chars inside them.

And also note that, while in this example it won't cause a problem, fgets stores the newline character, '\n' in the buffers also; gets() does not. If you compared the user input from fgets() to a string literal such as "abc" it would never match (unless the buffer was too small so that the '\n' wouldn't fit in it).

Here you have a solution

int compare_info(char *array1, char *array2)
{
    if ((array1 == NULL) || (array2 == NULL))
        return 0;
    while ((*array1 != '\0') && (*array2 != '\0') && (*array1 == *array2))
    {
        array1++;
        array2++;
    }
    return (*array1 == *array2);
}

or perhaps you like this more

int compare_info(char *array1, char *array2)
{
    int i;

    i = 0;
    if ((array1 == NULL) || (array2 == NULL))
        return 0;
    while ((array1[i] != '\0') && (array2[i] != '\0') && (array1[i] == array2[i]))
    {
        i++;
    }
    return (array1[i] == array2[i]);
}

you can make the arguments const it would be better style since if you only want to compare the strings, you guarantee that the function wont modify them i mean compare_info(const char *array1, const char *array2)

Most of the time, calling a function like strcmp is the proper and the only way of reliably comparing two strings. Most of the time, checking pointer equality is not a reliable way.

The problem is that two different pointers can point to two different memory regions that contain separate copies of the same string. You can have this:

    +---+        +---+---+---+---+---+---+---+---+---+---+---+---+
p1: | *--------> | o | l | i | v | e | r |   | b | i | e | r |\0 |
    +---+        +---+---+---+---+---+---+---+---+---+---+---+---+

    +---+        +---+---+---+---+---+---+---+---+---+---+---+---+
p2: | *--------> | o | l | i | v | e | r |   | b | i | e | r |\0 |
    +---+        +---+---+---+---+---+---+---+---+---+---+---+---+

Or you can have this:

    +---+        +---+---+---+---+---+---+---+---+---+---+---+---+
p3: | *--------> | o | l | i | v | e | r |   | b | i | e | r |\0 |
    +---+        +---+---+---+---+---+---+---+---+---+---+---+---+
                   ^
    +---+          |
p4: | *------------'
    +---+

p1 and p2 point to different strings, so the pointers will compare unequal. p3 and p4 point to the same string, so the pointers will compare equal.

If the pointers compare equal, obviously strcmp will say the strings are equal, too. But if the pointers are different, the strings might be the same (as in p1 and p2), or they might be different.

Sometimes people write things like

if(str1 == str2 || strcmp(str1, str2) == 0)

This checks to see whether the two strings str1 and str2 are the same. If the pointers are equal, then the strings are the same, and only if the pointers are not equal does the code perform the (more expensive) call to strcmp to check the actual, pointed-to characters.

When you have two string literals in your program that happen to be the same, like

char *w = "oliver bier";
char *w2 = "oliver bier";

or

char *w = "oliver bier";
...
if(w == "oliver bier") { ... }

you can't predict, in general, whether their pointers will be the same or different, whether the compiler was clever enough to have one in-memory copy of the string do double duty for its use in multiple places. Once upon a time this "cleverness" was quite rare, although I gather that today it's pretty common.

Your approach with nested loops isn't very well thought-out.

Clearly it will compare all letters of the second string against the first letter of the first string, then do the same for the second letter of the first string, and so on. Not at all the desired behavior.

Re-implementing strcmp() isn't very hard, here's a shot:

Copyint my_strcmp(const char *a, const char *b)
{
  for(; *a && *b && *a == *b; ++a, ++b)
    ;
  if(*a < *b)
    return -1;
  return *a > *b;
}

Note that it returns zero when the strings are equal. A good way to write a test is:

Copyif(my_strmcp(a, b) == 0)
{
  printf("two equal strings: '%s' and '%s'\n", a, b);
}

Some people write it as if(!my_strcmp()) but I don't recommend that, since it's mashing up so many concepts.

In C the char type has a numeric value so the > operator will work just fine for example

#include <stdio.h>
main() {

    char a='z';

    char b='h';

    if ( a > b ) {
        printf("%c greater than %c\n",a,b);
    }
}

I wouldn't say the code is okay in either language.

'a' is a single character. It is actually a small integer, having as its value the value of the given character in the machine's character set (almost invariably ASCII). So 'a' has the value 97, as you can see by running

char c = 'a';
printf("%d\n", c);

"a", on the other hand, is a string. It is an array of characters, terminated by a null character. In C, arrays are almost always referred to by pointers to their first element, so in this case the string constant "a" acts like a pointer to an array of two characters, 'a' and the terminating '\0'. You could see that by running

char *str = "a";
printf("%d %d\n", str[0], str[1]);

This will print

97 0

Now, we don't know where in memory the compiler will choose to put our string, so we don't know what the value of the pointer will be, but it's safe to say that it will never be equal to 97. So the comparison if(ch=="a") will always be false.

When you need to compare a character and a string, you have two choices. You can compare the character to the first character of the string:

if(c == str[0])
     printf("they are equal\n");
else printf("confusion\n");

Or you can construct a string from the character, and compare that. In C, that might look like this:

char tmpstr[2];
tmpstr[0] = c;
tmpstr[1] = '\0';

if(strcmp(tmpstr, str) == 0)
     printf("they are equal\n");
else printf("confusion\n");

That's the answer for C. There's a different, more powerful string type in C++, so things would be different in that language.

strcmp returns 0 when the strings are the same. I have code that uses strcmp comparing character arrays to string literals, and I was quite confused when it wasn't working. Turns out it was wrong for me to assume it would return 1 when the string are the same!

Maybe you've made the same mistake?