Funkcja nie działa jak powinna

Tak jak w tytule, próbuję rozwiązać zadanie z Symfonii C++, o takiej treści:

Mamy tablicę znaków, w której znajduje się długi C-string będący tekstem, składającym się z kilkunastu wyrazów. Napisz funkcje, która przekopiuje ten C-String do dwóch innych tablic. W tablicy parzyste znaleźć mają się parzyste wyrazy C-stringu, a w tablicy nieparzyste – nieparzyste wyrazy C-stringu. W obu docelowych tablicach wyrazy mają być oddzielone odstępami(spacjami), czyli znakami ' '. Funkcja ta ma być wywoływana z trzema argumentami:

• adres tablicy źródłowej,
• adres tablicy na wyrazy parzyste,
• adres tablicy na wyrazy nieparzyste.

A to mój kod:

#include <iostream>
#include <conio.h>

 /* for (int i = 0, k = 0; ; i+=2, k++)
    {
        cel[k]=oryg[i];
        if (oryg[i]==0)break;
    } */

using namespace std;

void kop(char oryg[], char parzyste[], char nieparzyste[])
{
    for (int i=0; ;i++ )
    {
            if (oryg[i]==0) break;

            if (i%2==0)
                parzyste[i]=oryg[i];

            else if (i%2!=0)
                nieparzyste[i]=oryg[i];
    }
}



int main()
{
    char tab[13]={"DOBRYWIECZOR"};
    char o_parzyste[15];
    char o_nieparzyste[15];

    kop(tab,o_parzyste,o_nieparzyste);

    cout<<o_parzyste<<endl<<endl;
    cout<<o_nieparzyste<<endl<<endl;

    getch();
}



 

No i nie idzie mi.. :( dostaje takie coś: http://scr.hu/0qk4l/digkp

Nie doczytałem w zadaniu nie znaki parzyste nieparzyste jak sugeruje kod autora, tylko wyrazy czyli jak rozumiem słowa:

void kop(char oryg[], char parzyste[], char nieparzyste[])
  {
   size_t p=0,n=0;
   for(size_t i=0;oryg[i];++i) (i&1?nieparzyste[n++]:parzyste[p++])=oryg[i];
   nieparzyste[n]=parzyste[p]=0;
  }
 
int main()
  {
   char tab[13]={"DOBRYWIECZOR"},o_parzyste[15],o_nieparzyste[15];
   kop(tab,o_parzyste,o_nieparzyste); 
   cout<<o_parzyste<<endl;
   cout<<o_nieparzyste<<endl;
   //getch(); // jeżeli to potrzebujesz to lepiej zmień swój IDE z poprzedniego tysiąclecia (dosłownie) na aktualny
   return  0;
  }

No wszystko super tylko nie za bardzo rozumiem. Przydałoby się bardziej przejrzyście, no i nie miałem jeszcze referencji

A getch() to przyzwyczajenie, zresztą co w tym złego??

void EvenOddWords(const char *src, char *evenWords, char *oddWords)
{
     while(*src)
     {
          while (*src && isspace(*src))
              ++src;

          while (*src && !isspace(*src))
              *evenWords++ = *src++;
          *evenWords++ = ' ';
          
          while (*src && isspace(*src))
              ++src;

          while (*src && !isspace(*src))
              *oddWords++ = *src++;
          *oddWords++ = ' ';
     }
     *evenWords = 0;
     *oddWords = 0;
}

Przy czym wyrazy indeksuje po informatycznemu (od zera).
http://ideone.com/97Bzh4

MarekR22 chyba nie przeczytałeś pierwszego postu wystarczająco dobrze, a jedynie spojrzałeś, bo nie dość, że chodzi mi o kod w C++ to jeszcze jestem laikiem, a to co ty napisałeś to całkowicie odległy świat.

int main(){

char tab[13]= "DOBRYWIECZOR";
char o_parzyste[20];
char o_nieparzyste[20];

int parzyste_count = 0;
int nieparzyste_count = 0;

for(int i =0; tab[i] != '\0'; i++){
if(i % 2 ==0){
o_parzyste[parzyste_count] = tab[i];
o_parzyste[parzyste_count + 1] = ' ' ;
parzyste_count = parzyste_count + 2;
}else{

    o_nieparzyste[nieparzyste_count] = tab[i];
     o_nieparzyste[nieparzyste_count + 1] = ' ';
     nieparzyste_count = nieparzyste_count + 2;
}

}

//zakoncz
o_nieparzyste[nieparzyste_count] = '\0';
o_parzyste[parzyste_count] = '\0';

//pokaz wynik
printf("oryginalny = %s\n",tab);
printf("parzyste = %s\n",o_parzyste);
printf("nieparzyste = %s\n",o_nieparzyste);

}

//output
oryginalny = DOBRYWIECZOR
parzyste = D B Y I C O
nieparzyste = O R W E Z R

o cos takiego Ci chodzilo?
ps. kod napisany w C

int main(){
char tab[13]= "DOBRYWIECZOR";
char o_parzyste[20];
char o_nieparzyste[20];

int parzyste_count = 0;
int nieparzyste_count = 0;

for(int i =0; tab[i] != '\0'; i++){
if(i % 2 ==0){
o_parzyste[parzyste_count] = tab[i];
o_parzyste[parzyste_count + 1] = ' ' ;
parzyste_count = parzyste_count + 2;
}else{

    o_nieparzyste[nieparzyste_count] = tab[i];
     o_nieparzyste[nieparzyste_count + 1] = ' ';
     nieparzyste_count = nieparzyste_count + 2;
}

}

//zakoncz
o_nieparzyste[nieparzyste_count] = '\0';
o_parzyste[parzyste_count] = '\0';

//pokaz wynik
printf("oryginalny = %s\n",tab);
printf("parzyste = %s\n",o_parzyste);
printf("nieparzyste = %s\n",o_nieparzyste);

}

//result
oryginalny = DOBRYWIECZOR
parzyste = D B Y I C O
nieparzyste = O R W E Z R

O cos takiego Ci chodzilo?
ps. kod napisany w C ale mozesz latwo zamienic na C++

szym3ns napisał(a):

MarekR22 chyba nie przeczytałeś pierwszego postu wystarczająco dobrze, a jedynie spojrzałeś, bo nie dość, że chodzi mi o kod w C++ to jeszcze jestem laikiem, a to co ty napisałeś to całkowicie odległy świat.

Ręce opadają. Dostosowałem się tylko do prototypu twojej funkcji. To czy tablica czy wskaźniki nie ma znaczenia, jeśli masz odrobinę oleju w głowie, przerobienie tego na tablice to naprawdę żaden problem, filozofia pozostaje bez zmian.
w C++ jest dużo łatwiej. Dam inny kod, ale z wyrzutami sumienia że hoduję kolejnego … .

void EvenOddWords(std::istream& src, std::ostream& evenWords, std::ostream& oddWords)
{
	std::string word;

	while (src >> word) {
		evenWords << ' ' << word;
		if (src >> word)
			oddWords << ' ' << word;
		else
			break;
	}
}

void EvenOddWords(const std::string& src, std::string& evenWords, std::string& oddWords)
{
	std::ostringstream evenStream, oddStream;
	std::istringstream srcStream(src);
	EvenOddWords(srcStream, evenStream, oddStream);
	evenWords = evenStream.str();
	oddWords = oddStream.str();
}

Edit: poprawiłem literówki itp.
http://ideone.com/YLM5P4

Dobra, już sobie poradziłem. Nie Marek, nie hodujesz kolejnego lenia.

Daje kod jakby ktoś kiedyś zajrzał, ładny i PRZEJRZYSTY, myślę że każdy kto też skończył rozdział "Tablice" i jest noobkiem jak ja zrozumie i będzie mi wdzięczny po 101014038034089423089 kroć

#include <iostream>
#include <conio.h>

using namespace std;

void kop(char oryg[], char parzyste[], char nieparzyste[])
{
    int i = 0;
    for (i ;; i++ )
    {
            if (i%2)
            {
                parzyste[i]=oryg[i];
                nieparzyste[i]= ' ';
            }

            else
            {
                nieparzyste[i]=oryg[i];
                parzyste[i] = ' ';
            }

            if (oryg[i]==0) break;
    }
    nieparzyste[i] = '\0';
    parzyste[i] = '\0';  //trzeba przypisac znak konca (null czy tam 0 jak kto woli) po zakonczeniu petli, zeby sie wyswietlalo normalnie

}

int main()
{
unsigned const rozmiar = 10;
char zrodlo[9]={"INSTYTUT"};
char parzyst[rozmiar];
char nieparzyst[rozmiar];

cout<<"Oryginalny tab: "<<zrodlo<<endl<<endl;

kop(zrodlo,parzyst,nieparzyst);

cout<<"Litery parzyste: "<<parzyst<<endl<<"Litery nieparzyste: "<<nieparzyst;

getch();
}

Niemniej dzięki _13th_Dragon, że po prawie 2 godzinach wyjaśniłeś łaskawie o co tam chodziło w twoim kodzie.

MarekR22 próbowałeś mi wciskać na siłę coś czego nie rozumiem, to jest dział Newbie, opisałem w jakim momencie kursu "utknąłem", a ty mi piszesz rzeczy, które są dla mnie w ogóle nie zrozumiałe (cały czas to powtarzałem) i jeszcze mi mówisz, że jakbym miał trochę oleju w głowie to bym zrozumiał, hehe. Oczywiście, że zrozumiałbym, ale dopiero gdybym przerobił całe 2 tomy Symfonii ze 4 razy. No ale dość już tych kłótni

Problem solved.

szym3ns napisał(a):

Daje kod jakby ktoś kiedyś zajrzał, ładny i PRZEJRZYSTY, myślę że każdy kto też skończył rozdział "Tablice" i jest noobkiem jak ja zrozumie i będzie mi wdzięczny po 101014038034089423089
A skąd?! W zadaniu:
W tablicy parzyste znaleźć mają się parzyste wyrazy C-stringu, a w tablicy nieparzyste – nieparzyste wyrazy C-stringu
A to co ty napisałeś to - W tablicy parzyste znajdują się parzyste LITERY C-stringu, a w tablicy nieparzyste – nieparzyste LITERY C-stringu.

Aczkolwiek nie spodziewam się zrozumienia różnicy pomiędzy literą a wyrazem.

char parzyst[10];
char nieparzyst[10];

//mozna jeszcze pomniejszyc rozmiar tablicy np.
char parzyst[5];
char nieparzyst[5];

sorry zapomnialem o ' '

Biały Lew napisał(a):

char parzyst[10];
char nieparzyst[10];

//mozna jeszcze pomniejszyc rozmiar tablicy np.
char parzyst[5];
char nieparzyst[5];

No w sumie prawda, dzięki wielkie, już poprawiam :)

@Edit
Ale to w sumie zależy od wyrazu, jaki siedzi w tablicy, z której chcemy wyciągnąć parzyste i nieparzyste literki, więc chyba lepiej będzie jak każdy sam sobie ustali jaki rozmiar chce w odpowiedniej zmiennej :P

To co napisałeś da się zrobić w sposób o wiele bardziej prosty:

void kop(char src[],char even[],char odd[])
  {
   size_t s=strlen(src);
   memcpy(even,src,s+1);
   memcpy(odd,src,s+1);
   for(size_t i=1;i<s;i+=2) even[i]=' ';
   for(size_t i=0;i<s;i+=2) odd[i]=' ';
  }

ale z całą pewnością nie chodzi o litery tylko o wyrazy.

_13th_Dragon napisał(a):

To co napisałeś da się zrobić w sposób o wiele bardziej prosty:

void kop(char src[],char even[],char odd[])
  {
   size_t s=strlen(src);
   memcpy(even,src,s+1);
   memcpy(odd,src,s+1);
   for(size_t i=1;i<s;i+=2) even[i]=' ';
   for(size_t i=0;i<s;i+=2) odd[i]=' ';
  }

ale z całą pewnością nie chodzi o litery tylko o wyrazy.

W zadaniu chodzi o to, żeby napisać własną funkcje, która to robi, a nie korzystać z już istniejących.

Eh się uparliście na te wyrazy, w takim razie dałoby rade przerobić LEKKO mój kod, żeby chodziło o wyrazy?

Przeszukałem internet i znalazłem rozwiązanie autora książki.
Rozwiązanie ewidentnie posługuje się CAŁYMI słowami rozróżnianymi za pomocą spacji!
Równocześnie 99% znalezisk to było rozwiązanie błędne oparte o litery i uznane za prawidłowe.
Ktoś zrobił źle, ogłosił, że jest dobrze i wszyscy mądrzy inaczej skopiowali rozwiązanie tyle razy, że trudno znaleźć coś innego.

szym3ns napisał(a):

W zadaniu chodzi o to, żeby napisać własną funkcje, która to robi, a nie korzystać z już istniejących.
Czyli jeszcze prościej:

void kop(char src[],char even[],char odd[])
  {
   size_t s=0;
   for(;(even[s]=odd[s]=src[s])!='\0';++s) {}
   for(size_t i=1;i<s;i+=2) even[i]=' ';
   for(size_t i=0;i<s;i+=2) odd[i]=' ';
  }

#include <iostream>
#include <conio.h>

using namespace std;


void kop(char src[], char parzyste[], char nieparzyste[])
{
    bool spr = false;

    for( int p = 0, n = 0, i = 0; ; i++)
    {
        if(src[i] == 0) break;

        if(spr == false)
        {
            nieparzyste[n] = src[i];
            n++;
        }
        if(spr == true)
        {
            parzyste[p] = src[i];
            p++;
        }


        if(src[i] == ' ') spr = !spr;

    }
}


int main()
{
    unsigned const rozmiar = 50;
    char zrodlo[] = { "Cos to na nie tak forum."};
    char parzyst[rozmiar] = {"tekst"};
    char nieparzyst[rozmiar] = {"tekst"};

    kop(zrodlo, parzyst, nieparzyst);
    cout<<"Oryginalny tab: "<<zrodlo<<endl
        <<"Wyrazy parzyste: "<<parzyst<<endl
        <<"Wyrazy nieparzyste: "<<nieparzyst;


    getch();
}
 

Już sobie poradziłem, myślę, że tak jest prościej dla mnie, no i rozumiem :P