HTML

Programozó Páternoszter

Ez a Programozó Páternoszter (PP) blogja, a programozásról szól. Aktualitása, hogy a Debreceni Egyetem Informatikai Kara Magasszintű programozási nyelvek 1-2, C++ esattanulmányok, Java esettanulmányok című kurzusainak blogja is egyben.

A szerző

Bátfai Norbert

Create Your Badge

A vadászat

A Debreceni Egyetem Programozói Évkönyve: az UDPROG projekt. A szakmai fórumunk a Facebook-en. Az új előadások a prezin.
A régi előadások:
Prog1:
1. C bevezetés
2. C tárgyalás
3. C befejezés
4. C a gyakorlatban
5. C++ bevezetés
6. C++ tárgyalás
7. C++ befejezés
8. C++ a gyakorlatban
9. Java platform bevezetés
10. Kvantuminformatikai alg. bev.
Prog2:
1. Java bevezetés
2. Java tárgyalás
3. Java befejezés
4. Java a gyakorlatban
5. Software Engineering bev.
6. Java EE bevezetés
7. AspectJ bevezetés
8. BPMN-BPEL SOA programozás
9. C++ haladó
10. Tensorflow

Kövess engem!

Keresés

Friss topikok

Linkblog

Blogajánló

Archívum

Feedek

XML

A forrás szövete, avagy *dest++ = *src++

2011.02.06. 19:21 nb

Módosítgassuk az első előadásban felvillantott, az strncpy könyvtári függvény manuáljabeli példa alapján megírt implementációnkat, hogy a forrásban kezdjen úgy kinézni néhány sor, mint amilyenek a C programok szoktak lenni!

Például az Androidos telefonok Linux kernelében előfordul ilyesmi: *src++? Lássuk, hozzuk le a forrást:

[norbi@sgu Android]$ git clone git://android.git.kernel.org/kernel/common.gits keressük benne az említett mintát:

[norbi@sgu Android]$ find . -name '*'|xargs grep "*src++"|wc
174     804   10699 nem vitás, a profik is írnak ilyeneket, esetleg pillantsunk is bele a common/include/linux/fb.h forrásába, 1026. sor.

 

Harmadik kisbajnokság

Nyeri, aki a fenti string_masolo_man_pl_alapjan függvényt rövidebben megírja egy kommentben, február 17, 15:30-ig. A hossz a függvény testének nyitózárójelétől a bezáróig, őket nem beleértve a felhasznált nem szóköz betűk száma. Így az enyém most 75:

  int i;
  char *p = d;

  for (i = 0; i < n && (*d++ = *s++); i++)
    ;

  for (; i < n; i++)
    p[i] = '\0';  

  return p

Facebook Tumblr Tweet Pinterest Tetszik
0

25 komment

Címkék: android kernel find grep xargs git

Ajánlott bejegyzések:

A bejegyzés trackback címe:

https://progpater.blog.hu/api/trackback/id/tr692642797

Kommentek:

A hozzászólások a vonatkozó jogszabályok  értelmében felhasználói tartalomnak minősülnek, értük a szolgáltatás technikai  üzemeltetője semmilyen felelősséget nem vállal, azokat nem ellenőrzi. Kifogás esetén forduljon a blog szerkesztőjéhez. Részletek a  Felhasználási feltételekben és az adatvédelmi tájékoztatóban.

basecamp 2011.02.10. 18:44:36

char *p = d;
while(n--) *d++=*s++;
return p;
Válasz erre 

nb · http://fersml.blog.hu 2011.02.10. 20:16:19

Szép, de ugyanaz-e már ez?

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
basecamp (char *d, const char *s, int n)
{

char *p = d;

while (n--)
*d++ = *s++;

return p;
}

char *
nb (char *d, const char *s, int n)
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
return 0;
}
Válasz erre 

borokcs 2011.02.10. 20:54:33

@basecamp:

#include <iostream>
#include <stdio.h>

#define MERET 5

using namespace std;

char * stringMasolBatfai(char *dest, const char *src, int n){
int i;
char *p = dest;

for (i = 0; i < n && (*dest++ = *src++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

char * stringMasolRovidebb(char *dest, const char *src, int n){
int e=0;
while (e!=n){
dest[e] = src[e];
++e;
}
return dest;
}

int main()
{
char *p;

char *buffer;

p = stringMasolRovidebb(buffer, "cc", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = stringMasolRovidebb(buffer, "aaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = stringMasolRovidebb(buffer, "bbbbbbbbbbbbbbb", MERET-1);
printf ("[%s] [%s]\n", buffer, p);

return 0;
}

// Ez a 75 karakter valójában 76 mert a "return p" után kell egy ";" különben nem fut le.
// És be kell deklarálni a buffert.
Válasz erre 

basecamp 2011.02.10. 21:10:39

@nb: hopp rosszat küldtem
char *p;
while (n--&&(*d++=*s++));
return p;
Válasz erre 

Veyron007 2011.02.10. 21:12:08

#include <stdio.h>
#include <conio.h>

char *masol ( char *a, char *b, int n ){
int i=0;
for(;i<n && b[i]!='\0';i++) a[i]=b[i];
a[i]='\0';
return a;
}

int main(int argc, char* argv[]){
char *e,*er;

er = masol(&e,"alma",2);
printf("%s\n",er);
getch();
return 0;
}
Válasz erre 

nb · http://fersml.blog.hu 2011.02.10. 21:15:38

@borokcs: szerintem az nb()-ben:

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;

75 betű van, basecamp () ránézésre kevesebb, de a fent bevágott kód mutatja, hogy nem pont ugyanazt csinálja.

Nálad miért keveredik a C és a C++?

S íme: a Tiéd sem azt:

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
borokcs (char *d, const char *s, int n)
{

int e = 0;
while (e != n)
{
d[e] = s[e];
++e;
}

return d;
}

char *
basecamp (char *d, const char *s, int n)
{

char *p = d;

while (n--)
*d++ = *s++;

return p;
}

char *
nb (char *d, const char *s, int n)
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };
p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
return 0;
}
Válasz erre 

nb · http://fersml.blog.hu 2011.02.10. 21:20:37

@Veyron007: saját megoldásotokat az alábbi kódba tegyétek be kipróbálni, így a változó nevek is fognak egyezni, könnyebb kipróbálni. (conio.h honnan jött? még dos-os harcos koromban a BC 3.1-ben láttam ilyet vagy 15 éve :-)

Ugye nem Windows alatt vagy?

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
borokcs (char *d, const char *s, int n)
{

int e = 0;
while (e != n)
{
d[e] = s[e];
++e;
}

return d;
}

char *
basecamp (char *d, const char *s, int n)
{

char *p = d;

while (n--)
*d++ = *s++;

return p;
}

char *
nb (char *d, const char *s, int n)
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };
p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
return 0;
}
Válasz erre 

szimih 2011.02.10. 21:33:44

char *szimih(char *d, const char *s,int n)
{
char *p = d;

while (n-- && (*d++ = *s++))
;
while(n-- > 0)
*d++='\0';

return p;
}
Válasz erre 

basecamp 2011.02.10. 22:23:31

@basecamp:

char *p;
while (n--&&(*d++=*s++));
return p;

úgy gondolom ez a legrövidebb megoldás és azért nem nullázom ki a végét mert a *s++ nullát ad vissza ha már "kimentünk belőlle"
Válasz erre 

basecamp 2011.02.10. 23:13:24

@basecamp: Egy manuálisan nullázó vezió
char *p=d;
while(n--) *d++ = *s ? *s++ : '\0';
return p
Válasz erre 

nb · http://fersml.blog.hu 2011.02.11. 11:54:42

Ezzel teszteljétek, eddig talán 4 versenyző van, aki +-ban jön, írja bele magát és mindenki írja be kommentben a hosszát is:

a 2. még nem ugyanazt adja:

[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] [yy]
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
szimih (char *d, const char *s, int n)
{
char *p = d;

while (n-- && (*d++ = *s++))
;
while (n-- > 0)
*d++ = '\0';

return p;
}

char *
borokcs (char *d, const char *s, int n)
{

int e = 0;
while (e != n)
{
d[e] = s[e];
++e;
}

return d;
}

char *
basecamp (char *d, const char *s, int n)
{
char *p = d;

while (n--)
*d++ = *s ? *s++ : '\0';

return p;
/*
char *p = d;

while (n--)
*d++ = *s++;

return p;
*/
}

char *
nb (char *d, const char *s, int n) // 75 betű
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };

p = szimih (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
p = szimih (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf("-----------\n");

p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = borokcs (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf("-----------\n");

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

return 0;
}
Válasz erre 

borokcs 2011.02.11. 12:19:10

int e=0;
while ( s[e] != '\0' && e<n )
d[e] = s[e++];
return d;
Válasz erre 

borokcs 2011.02.11. 12:19:46

#define MERET 5
char buffer[MERET];

char *
borokcs (char *d, const char *s, int n)
{

int e = 0;
while (e != n)
{
d[e] = s[e];
++e;
}

return d;
}

char *
basecamp (char *d, const char *s, int n)
{

char *p = d;

while (n--)
*d++ = *s++;

return p;
}

char *
nb (char *d, const char *s, int n)
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };
p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
return 0;
}
Válasz erre 

nb · http://fersml.blog.hu 2011.02.11. 13:37:48

@borokcs: még mindig nem azt adja szerintem, mint a másik3:

[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] [yy]
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
Válasz erre 

borokcs 2011.02.12. 13:30:45

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
szimih (char *d, const char *s, int n)
{
char *p = d;

while (n-- && (*d++ = *s++))
;
while (n-- > 0)
*d++ = '\0';

return p;
}

char *
borokcs (char *d, const char *s, int n)
{

int e=0;
while(s[e]!='\0' && e<n)
d[e] = s[e++];
return d;

}

char *
basecamp (char *d, const char *s, int n)
{
char *p = d;

while (n--)
*d++ = *s ? *s++ : '\0';

return p;
/*
char *p = d;

while (n--)
*d++ = *s++;

return p;
*/
}

char *
nb (char *d, const char *s, int n) // 75 betű
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };

p = szimih (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
p = szimih (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf("-----------\n");

p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = borokcs (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf("-----------\n");

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

return 0;
}
Válasz erre 

nb · http://fersml.blog.hu 2011.02.12. 17:12:03

@borokcs: kipróbáltad? Mert mintha a másik 3-hoz viszonyítva még mindig máshogy működne:

[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xxbba] [xxbba] [ba]
[ccbba] [ccbba]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
Válasz erre 

borokcs 2011.02.12. 17:19:07

kipróbáltam és nekem jó
Válasz erre 

borokcs 2011.02.13. 11:02:41

int e=0;

while(s[e]!='\0' && e<n)
d[e] = s[e++];

while(e<n)
d[e++] = '\0';

return d;

ezzel már biztos jó!
Válasz erre 

nb · http://fersml.blog.hu 2011.02.13. 15:30:34

@borokcs: igen itt tartunk most, ha valakinek rosszul számoltam, módosítsa:

63, 71, 45, 75

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
szimih (char *d, const char *s, int n) // 63 betu
{
char *p = d;

while (n-- && (*d++ = *s++))
;
while (n-- > 0)
*d++ = '\0';

return p;
}

char *
borokcs (char *d, const char *s, int n) // 71 betu
{
int e = 0;

while (s[e] != '\0' && e < n)
d[e] = s[e++];

while (e < n)
d[e++] = '\0';

return d;

}

char *
basecamp (char *d, const char *s, int n) // 45 betu
{
char *p = d;

while (n--)
*d++ = *s ? *s++ : '\0';

return p;
}
char *
nb (char *d, const char *s, int n) // 75 betu
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };

p = szimih (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
p = szimih (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = borokcs (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);
printf ("-----------\n");

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = basecamp (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = basecamp (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = nb (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

return 0;
}
Válasz erre 

christian3 2011.02.16. 00:20:01

char *p= d;
while (n-- && (*d++ = *s++)) ;
while (n--) *d++='\0';
return p;
Válasz erre 

nb · http://fersml.blog.hu 2011.02.16. 09:25:56

@christian3: pls a kódod tett a nicked nevű függvénybe, fejel után // betűvel, a main-ben a tesztsorokkal és azt küld be.
Válasz erre 

christian3 2011.02.16. 10:05:38

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
christian3 (char *d, const char *s, int n) // 61 betu
{
char *p= d;
while (n-- && (*d++ = *s++)) ;
while (n--) *d++='\0';
return p;
}

char *
szimih (char *d, const char *s, int n) // 63 betu
{
char *p = d;

while (n-- && (*d++ = *s++))
;
while (n-- > 0)
*d++ = '\0';

return p;
}

char *
borokcs (char *d, const char *s, int n) // 71 betu
{
int e = 0;

while (s[e] != '\0' && e < n)
d[e] = s[e++];

while (e < n)
d[e++] = '\0';

return d;

}

char *
basecamp (char *d, const char *s, int n) // 45 betu
{
char *p = d;

while (n--)
*d++ = *s ? *s++ : '\0';

return p;
}

char *
nb (char *d, const char *s, int n) // 75 betu
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };

p = szimih (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);
p = szimih (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = borokcs (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = borokcs (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);
printf ("-----------\n");

p = basecamp (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = basecamp (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = basecamp (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = nb (buffer, q, MERET);
printf ("[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

return 0;
}
Válasz erre 

nb · http://fersml.blog.hu 2011.02.16. 19:58:42

@christian3: futtattad? Mert nekem ezt adja:

szimih
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
borokcs
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
basecamp
[xx] [xx] []
[cc] [cc]
[aaaaa] [aaaaa]
[bbbba] [bbbba]
-----------
christian3
[xx] [xx] []
[cc] [cc]
Szegmens hiba

#include <stdio.h>

#define MERET 5
char buffer[MERET];

char *
christian3 (char *d, const char *s, int n) // 61 betu
{
char *p = d;
while (n-- && (*d++ = *s++));
while (n--)
*d++ = '\0';
return p;
}

char *
szimih (char *d, const char *s, int n) // 63 betu
{
char *p = d;

while (n-- && (*d++ = *s++))
;
while (n-- > 0)
*d++ = '\0';

return p;
}

char *
borokcs (char *d, const char *s, int n) // 71 betu
{
int e = 0;

while (s[e] != '\0' && e < n)
d[e] = s[e++];

while (e < n)
d[e++] = '\0';

return d;

}

char *
basecamp (char *d, const char *s, int n) // 45 betu
{
char *p = d;

while (n--)
*d++ = *s ? *s++ : '\0';

return p;
}
char *
nb (char *d, const char *s, int n) // 75 betu
{

int i;
char *p = d;

for (i = 0; i < n && (*d++ = *s++); i++)
;

for (; i < n; i++)
p[i] = '\0';

return p;
}

int
main ()
{

char *p;
char q[] = { 'x', 'x', '\0', 'y', 'y' };

p = szimih (buffer, q, MERET);
printf ("szimih\n[%s] [%s] [%s]\n", buffer, p, buffer + 3);
p = szimih (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = szimih (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = borokcs (buffer, q, MERET);
printf ("borokcs\n[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = borokcs (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = borokcs (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);
printf ("-----------\n");
p = basecamp (buffer, q, MERET);
printf ("basecamp\n[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = basecamp (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = basecamp (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = basecamp (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = christian3 (buffer, q, MERET);
printf ("christian3\n[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = christian3 (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = christian3 (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = christian3 (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

printf ("-----------\n");

p = nb (buffer, q, MERET);
printf ("nb\n[%s] [%s] [%s]\n", buffer, p, buffer + 3);

p = nb (buffer, "cc", MERET);

printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "aaaaaaaaaaaaaaaaaaaaaaaaaaa", MERET);
printf ("[%s] [%s]\n", buffer, p);

p = nb (buffer, "bbbbbbbbbbbbbbbbbbbbbbbbbbb", MERET - 1);
printf ("[%s] [%s]\n", buffer, p);

return 0;
}
Válasz erre 

nb · http://fersml.blog.hu 2011.02.17. 15:32:43

@nb: az idő lepergett, a győztes basecamp, Övé a kisbajnokság.
Válasz erre 
süti beállítások módosítása