Program zamieniający małe litery na duże i odwrotnie.

Mam za zadanie napisać program zmieniający małe litery na duże(bez biblioteki ctype.h), ma to się odbywać w funkcji, oraz działać na wskaźnikach.
Niestety nie wiem co robię źle.

int change_letter_size(const char* src, char* dest)
{
    int i;
    char temp;
    for(i=0;i<1009;i++)
    {
        if(*(src+i)=='\0')
            {
                break;
            }
        else
        {
            if(*(src+i)>65 && *(src+i)<90)
                {
                    temp=*(src+i);
                    *(dest+i)=temp+32;
                }
            else if(*(src+i)>97 && *(src+i)<122)
                {
                    temp=*(src+i);
                    *(dest+i)=temp-32;
                }
        }
      //  printf("%d %d \n",i,j);
     //   printf("%c ",*(dest+i));
    }
    return 1;
}
int main()
{
    char txt[1010];
    char txt2[1010];
    char* src=&txt[0];
    char* dest=&txt2[0];
    
    printf("Wprowadź tekst:  ");
    fgets(src,1010,stdin);
    
    change_letter_size(src,dest);
  // fputs(src,stdout);
  // fputs(dest,stdout);
    return 0;
}

Helliot napisał(a):

Mam za zadanie napisać program zmieniający małe litery na duże(bez biblioteki ctype.h) […]

A czy wymagane jest kopiowanie ciągu, czy masz zamianę przeprowadzić na tym oryginalnym? Bo w sumie to niepotrzebnie kombinujesz z tym przepisywaniem danych z src do dest, skoro tego src i tak później nie wykorzystujesz.

ma to się odbywać w funkcji, oraz działać na wskaźnikach.

A nie wolałbyś iterować po ciągu mając wskaźnik na znak? W pętli while warunkiem iteracji będzie wartość iteratora różna od znaku NULL (o kodzie 0). Wtedy nie musiałbyś w środku pętli tworzyć dodatkowych warunków i przerywać jej działania za pomocą break.

1. Niestety te 2 ciągi są wymagane.

2. Jak najbadziej mogę, tylko myśle, że to nie rozwiąże mojego problemu.
   Problem gdzieś (chyba) leży w przypisywaniu wartości w pętlach.

No dobrze, skoro dwa ciągi są wymagane, to pozostaje jeszcze kwestia złej pętli i niepotrzebnych zmiennych.

Poniżej podaję przykład działania funkcji zmieniającej wielkość liter w ciągu (stworzony w sumie metodą prób i błędów – C nie jest moim natywnym językiem). Ciąg jest kopiowany, więc ten źródłowy pozostaje nienaruszony.

void swapls(char* source, char* dest)
{
  while(*source != '\0')               // jeśli to nie koniec ciągu
  {
    *dest = *source;                   // przepisz znak do ciągu docelowego
 
    if(*dest >= 65 && *dest <= 90)     // jeśli bieżący znak to duża litera
      *dest += 32;                     // zwiększ jego kod o 32
    else                               // w przeciwnym razie
      if(*dest >= 97 && *dest <= 122)  // jeśli bieżący znak to mała litera
        *dest -= 32;                   // zmniejsz jego kod o 32
 
    ++source;                          // zwiększ adres wskaźnika źródłowego o jeden
    ++dest;                            // zwiększ adres wskaźnika docelowego o jeden
  }

  *dest = '\0';                        // zakończ ciąg docelowy znakiem NULL
}

Warunek jest taki, że source musi być zakończony znakiem NULL, ale to raczej normalne. Operuję bezpośrednio na parametrach, dzięki czemu dodatkowe lokalne zmienne nie są wymagane. Przykład wywołania:

int main()
{
  char source[32] = "foo-32_BAR+64(bald)\0";
  char dest[32];
  
  printf("%s\n", source);
  swapls(&source[0], &dest[0]);
  printf("%s\n", dest);
  
  return 0;
}

Wyjście:

foo-32_BAR+64(bald)
FOO-32_bar+64(BALD)

Jeśli chciałbyś zmieniać zawartość oryginalnego ciągu (bez jego kopiowania) to funkcja może wyglądać tak:

void swapls(char* line)
{
  while(*line != '\0')                 // jeśli to nie koniec ciągu
  {
    if(*line >= 65 && *line <= 90)     // jeśli bieżący znak to duża litera
      *line += 32;                     // zwiększ jego kod o 32
    else                               // w przeciwnym razie
      if(*line >= 97 && *line <= 122)  // jeśli bieżący znak to mała litera
        *line -= 32;                   // zmniejsz jego kod o 32
 
    ++line;                            // zwiększ adres wskaźnika o jeden
  }
}

Gdybym coś źle sugerował to proszę, poprawcie mnie. Linki do testowanych kodów:

• wersja z kopiowaniem: https://onlinegdb.com/S1Ouc0lhG
• wersja bez kopiowania: https://onlinegdb.com/SyHh_Axhz

Dzięki wielkie za pomoc , wszystko działa :)

Po co te magiczne liczby? Użyj toupper i tolower.

Zabronili używać bibliotek ictype.h .

To przekaż prowadzącemu, że uczenie złych praktyk to idiotyzm :​/

Może to być moja ostatnia rozmowa z prowadzącym :)

Jesteś w stanie mi powiedzieć, czemu to nie działa?
Program zamieniający spacje na "podłogę".
Schemat działania powinien być dokładnie ten sam.

#include <stdio.h>

int space_changer(char* t)
{
    if(!t)
    {
        return 0;
        
    }
    else
    {
        while(*t!='\0')
        {
            if(*t==32)
            {
                *t+=63;
                ++t;
            }
        }
    }
    return 1;
}

int main()
{
    char txt[1010];
    char*t=&txt[0];
    printf("Podaj text ");
    fgets(t,1010,stdin);
  space_changer(t);
    fputs(t,stdout);
    return 0;
}

Może to być moja ostatnia rozmowa z prowadzącym :)

Na ostatniej na pewno warto mu to zakomunikować.

Masz pętlę nieskończoną jeśli znakiem jest cokolwiek innego niż spacja.

*t+=63;

uwielbiam takie magiczne liczby. Co tu się dzieje? Nie dało się tego sensownie zapisać?

Pewnie,że się dało. To był mój jakiś 10 pomysł na to zadanie :) dlatego taki dziwny

   while(*t!='\0')
        {
           if(*t==' ')
            {
                *t='_';
              
            }
              t++;
        
        }

Jeszcze raz dzięki za pomoc

@Helliot: w sumie to sam mogłem użyć znakowych literałów, zamiast tych liczbowych z kodami:

void swapls(char* source, char* dest)
{
  while(*source != '\0')
  {
    *dest = *source;
    
    if(*dest >= 'A' && *dest <= 'Z')
      *dest += 32;
    else
      if(*dest >= 'a' && *dest <= 'z')
        *dest -= 32;
  
    ++source;
    ++dest;
  }
  
  *dest = '\0';
}

Od razu wiadomo o co chodzi – nie trzeba się domyślać znaczenia gołych liczb.

furious programming napisał(a):

Od razu wiadomo o co chodzi – nie trzeba się domyślać znaczenia gołych liczb.

No nie do końca. Została Ci jeszcze jedna stała magiczna. Chodzi mi o tą 32. Idealnie by było wydzielić to jako nową zmienną nie przejmując się jej wartością.

int offset = 'a' - 'A';

*dest += offset;

Wtedy już będzie w 100% jasne co skąd pochodzi :)