Operacje na char* w argumencie funkcji.

Mam taką funkcję:

void conv(char *xcv,char *zzzz,char *aaa)
{
     printf("Przed konwersja: %c\n\n",*zzzz);
     
     uint8_t bytes[sizeof(xcv)];
     uint8_t *byte = (uint8_t *) &xcv;
     
     uint8_t *byte2 = (uint8_t *) &zzzz;

     int ii;
     for (ii=0; ii<sizeof(xcv); ii++)
     {         
         bytes[ii] = *byte;
         byte++;
     }
     for (ii=0; ii<sizeof(xcv); ii++)
     {         
         printf("F: %d\n",bytes[ii]);
     }              
     for (ii=0; ii<sizeof(xcv); ii++)
     {         
         *byte2 = bytes[ii];
         byte2++;
     }
     printf("Po konwersji: %c\n\n",*zzzz);     
     *aaa = *zzzz;
}
 

Konwertuje ona char (lub po modyfikacji inne typy wbudowane) na tablice uint8_t, a potem z powrotem do char.

Próbuję ją przerobić tak, aby działała na tablicy znaków char*, ale nie wychodzi mi.
Chodzi o to, żeby przesłać do funkcji wskaźnik do char* i operować na nim, a nie na kopii zmiennej.

Ogólnie w argumencie powinny być chyba char**, ale po jedynie takiej zmianie nie działa.

Pomoże ktoś?

void conv(char *xcv, ...)
{
    sizeof(xcv) //<--- wtf?!

Coś mi się wydaje, że z ostatniego wątku nie wyciągnąłeś odpowiednich wniosków. Przeczytaj go uważnie jeszcze raz.

Dla typu char działa. Dla char* powinno być strlen(*xcv)?

sizeof() zwraca ci ROZMIAR obiektu danego typu w BAJTACH (czyli sizeof(wskaznik) zwróci ci rozmiar wskaźnika, czyli zwykle 4 bajty). strlen() zwraca ci długość c-stringa (długość liczoną od poczatku do znaku '\0'). Zastanów się więc co chcesz zrobić.

Chodziło mi o długość c-stringa, bo muszę wiedzieć jak długą tablicę uintów muszę stworzyć.
Teraz mam inny problem, ponieważ wczytuję tablicę znaków char*, wpisuję ją do tablicy uintów, ale nie mogę z tej tablicy przepisać tego z powrotem do char*.
Oto kod:

 
void char_2(char **a)
{
     printf("************** char_2 *************\n\n");
     char **b;
     int ii;
     *a="ala1234";

     uint8_t bytes[strlen(*a)];
     uint8_t **byte = (uint8_t **) a;
     uint8_t **byte2 = (uint8_t **) b;     
     
     for (ii=0; ii<strlen(*a); ii++)
     {         
         printf("1\n");          
         bytes[ii] = *byte;
         *byte++;
     }    
     
     for(ii=0;ii<strlen(*a);ii++)
     {
         printf(" %d",bytes[ii]);     
     } 

     for (ii=0; ii<strlen(*a); ii++)
     {         
         printf("\n2\n");
         *byte2 = bytes[ii];
         byte2++;
     }     
     
     printf("\n************** char_2 *************\n\n");
}     

Problem jest w ostatniej pętli.

Rozumiem że wg ciebie zrobienie wskaźnika który pokazuje cholera_wie_na_jaki_obszar_pamięci a potem wpisywanie do tej pamięci czegoś to dobry pomysł? Może jednak warto doczytac coś na temat pamięci dynamicznej i wskaźników ZANIM zacznie się tworzyć takie potworki?

A jak w takim razie zrobić wskaźnik, który będzie pokazywał na podany w argumencie c-string xcv?
Muszę go wpisać do tablicy uintów.
Będzie to:
uint8_t *wsk = (uint8_t *) &xcv
???
Wtedy wyciągnięty adres z xcv będzie pokazywał na początek c-stringa?

Do takiego:

*a="ala1234";

Stringa nie możesz nic dopisać ani go modyfikować, bo jest stałą! Może jednak coś poczytasz?

To jest linia z jakiś poprzednich moich prób. Zapomnijmy o niej.

uint8_t *wsk = (uint *) &a;

tak??

Nie nie nie. Lekcja na dziś: malloc(), calloc(), realloc() i free()

Z tego co wiem ten kod będzie kompilowany na mikrokontrolerach AVR, i powiedziano mi, że być może tamte kompilatory mogą mieć problemy z funkcjami typu malloc.
Tak naprawdę potrzebuję dwóch funkcji. Jedna konwertuje char* do tablicy uintów i wysyła ją. Druga odbiera tablicę uintów i kowertuje do char*.

To zrób statyczną tablicę char'ów, ale nie rób stałych stringów, bo i tak ich nie zmienisz.
Poza tym czemu po prostu nie użyjesz sprintf()?

Chciałem tak zrobić ale mój promotor chciał char*. OK zrobię to na statycznej tablicy, ale chyba przy takim rozwiązaniu, nie można wywołać funkcji typu
fun(char[])
za pomocą:
fun("tekst")
prawda?

Prawda. Ale prawdą jest też to że gdybyś wywołał fun("tekst") to nie mógłbyś tego "tekst" w żaden sposób zmieniać, dopisywać, etc.
Ale nie rozumiem czemu nie zrobisz funkcji
fun(char*)
do której będziesz przekazywał char[] (które niejawnie można zrzutować na wskaźnik)

Shalom napisał(a)

Prawda. Ale prawdą jest też to że gdybyś wywołał fun("tekst") to nie mógłbyś tego "tekst" w żaden sposób zmieniać, dopisywać, etc.
Ale nie rozumiem czemu nie zrobisz funkcji
fun(char*)
do której będziesz przekazywał char[] (które niejawnie można zrzutować na wskaźnik)

Nie wiem czemu wbiłem sobie do głowy, że w takim wypadku będę operował na kopii obiektu.

Bo na kopii niejako będziesz pracował. Na kopii wskaźnika. Ale pamięć na którą on pokazuje będzie cały czas tam sama.