Ændre i indholdet af en char*

du skal vel returnere den nye char* ?

char* doStuff(char* source)
{
  source[2] = '\0';
  return source;
}

vil mit gæt være

så:

char* src = "some string";
char* src2 = doStuff(src);

Hvad bliver der så af det oprindelige indhold af src? Vil jeg ikke ende med en kopi af src og dermed bruge dobbelt så meget hukommelse?

jo, men du kan jo nok også genbruge den vil jeg mene...

char* src = "some string";
src = doStuff(src);

måske?

eller kan man nok slette den gamle src.

Du kunne jo også ændre det lidt:

char* doStuff(char* source)
{
  source[2] = '\0';
  return source;
}

char* src = doStuff("some string");

ved ikke helt om man kan på den måde, kan ikke teste det lige nu

Lad os så sige at jeg kører denne funktion en fantazillion gange - er der så ikke en måde at genbruge den oprindeligt allokerede hukommelse, så puteren slipper for at allokere/reallokere hukommelse en fantazillion gange?

eller skal du nok til noget pointer noget.. kan jeg ikke lige i hovedet...
Men noget med at src har en adresse og det er så i den du ændrer.

void doStuff(char* &source)
{
  source[2] = '\0';
}

char* src = "some string";
doStuff(src);


men kan ikke lige huske det i hovedet... Kan ikke teste :(

så smider den adressen på src med, og det er så den du skal ændre i...

Der er ikk enoget galt med din funktion !

#include <stdio.h>

void doStuff(char* source)
{
  source[2] = '\0';
}

int main()
{
  char src[] = "some string";
  printf("%s\n",src);
  doStuff(src);
  printf("%s\n",src);
  return 0;
}

virker fint hos mig !

Output:

C:\>z
some string
so

hvilket er korrekt.

Så fejlen må ligge et andet sted.

den skal vel ikke udskrive "some string" den skal jo udskifte [2] med '\0' , så der kommer vel til at stå noget andet??

Arne >> Så fatter jeg ikke hvad der går galt... Kan det passe at '\0' ikke bliver tolket som en null-terminering når man udskriver med cout << src << endl; ?

Ahhh... ok... havde ikke set "so"

Prøv med printf istedet og se om det har noget med det at gøre?

#include <iostream>

using namespace std;

void doStuff(char* source)
{
  source[2] = '\0';
}

int main()
{
  char src[] = "some string";
  cout << src << endl;
  doStuff(src);
  cout << src << endl;
  return 0;
}

giver også:

some string
so

Mit gæt er at du lader en pointer pege på noget, som er korrekt, og så
ændrer du det som pointeren peger på, og så er det forkert.

Poster lige den fulde source, da det tydeligvis ikke er teorien der fejler noget.

Output:
#0      [This is a test]
#1      [is a test]
#2      [a test]
#3      [test]


        ** Anykey **

Burde (som jeg opfatter det) #0 this, #1 is etc etc etc



#include <iostream>
#include <stdlib.h>

using namespace std;

int Split(char* dest[10], char* src, unsigned int length, char splitChar, char strChar);

int main(int argc, char *argv[])
{
    char* src = "This is a test";
    char* items[10];
    int idx, len;
    len = Split(items, src, strlen(src), ' ', '"');
   
    for(idx = 0; idx < len; idx++)
        cout << "#" << idx << "\t[" << items[idx] << "]" << endl;
   
    cout << "\n\n\t** Anykey **" << endl;
    getchar();
    return 0;
}

int Split(char* dest[10], char* src, unsigned int length, char splitChar, char strChar)
{
    int loc;   
    int idx = 1;
    bool esc = false;
    loc = 0;
    while(src[loc] == splitChar)
        loc++;
    if(src[loc] == strChar)
    {
        esc = true;
        loc++;
    }
    dest[0] = src + loc;
    for(loc++; loc < length; loc++)
    {
        if(!esc)
        {
            if(src[loc] == strChar)
            {
                esc = true;
                src[loc] == '\0';
                dest[idx++] = src + loc + 1;
            }
            else if(src[loc] == splitChar)
            {
                src[loc++] == '\0';
                while(src[loc] == splitChar)
                    loc++;
                dest[idx++] = src + loc;
            }
        }
        else
        {
            if(src[loc] == strChar)
            {
                if(src[loc - 1] == '\\')
                    continue;
                esc = false;
                src[loc++] = '\0';
                while(src[loc] == splitChar)
                    loc++;
                dest[idx++] = src + loc;
            }
        }
    }
    return idx;
}

hehe skummelt... fejl i ram ?? :) hehe

. o O (Så skulle jeg alligevel have dokumenteret min kode) :( Hader når min bedrevidende indre stemme har ret!

Det kan da ikke være linjen
dest[0] = src + loc;
der opretter en kopi af src og gemmer pointeren i dest[0] ??

Jeg er slet ikke glad for den måde du bruger memory på.

Det må du meget gerne uddybe - sætter gerne point op, eller falder på knæ og kalder dig code-guru hvis det hjælper... hehe

hehe... arne du tager bare over :)

#include <iostream>
#include <stdlib.h>

using namespace std;

int Split(char* dest[10], char* src, unsigned int length, char splitChar, char strChar);

int main(int argc, char *argv[])
{
    char src[] = "This is a test \"hello world\"";
    char* items[10];
    int idx, len;
    len = Split(items, src, strlen(src), ' ', '"');
 
    for(idx = 0; idx < len; idx++)
        cout << "#" << idx << "\t[" << items[idx] << "]" << endl;
 
    cout << "\n\n\t** Anykey **" << endl;
    getchar();
    return 0;
}

int Split(char* dest[10], char* src, unsigned int length, char splitChar, char strChar)
{
    bool esc = false;
    int idx = 0;
    dest[idx] = src;
    idx++;
    for(int loc=0;loc<length;loc++)
    {
        if(src[loc] == splitChar && !esc)
        {
            src[loc] = '\0';
            dest[idx] = src + loc + 1;
            idx++;
        }
        else if(src[loc] == strChar)
        {
            esc = !esc;
        }
        else
        {
            // nothing
        }
    }
    return idx;
}

Output:

C:\>zzzz
#0      [This]
#1      [is]
#2      [a]
#3      [test]
#4      ["hello world"]


        ** Anykey **

for each(dummefejl in my_source)

Så skal jeg bare finde ud af hvor...

Det løgn!! Jeg har bare IKKE skrevet == i stedet for = 100 steder...

Bemærk forskellen på disse to:

char* src = "This is a test";
char  src[] = "This is a test";

For god ordens skyld vil jeg lige poste slutresultatet... som endda er forholdsvist tilgivende overfor syntaxfejl :D

#include <iostream>
#include <stdlib.h>

using namespace std;

int Split(char* dest[10], char* src, unsigned int length, char splitChar, char strChar);

int main(int argc, char *argv[])
{
    char src[] = "This is \"a test\"ok";
    char* items[10];
    int idx, len;
    len = Split(items, src, strlen(src), ' ', '\"');
   
    for(idx = 0; idx < len; idx++)
        cout << "#" << idx << "\t[" << items[idx] << "]" << endl;
   
    cout << "\n\n\t** Anykey **" << endl;
    getchar();
    return 0;
}

int Split(char* dest[10], char* src, unsigned int length, char splitChar, char strChar)
{
    int loc;   
    int idx = 1;
    bool esc = false;
    loc = 0;
    while(src[loc] == splitChar)
        loc++;
    if(src[loc] == strChar)
    {
        esc = true;
        loc++;
    }
    dest[0] = src + loc;
    for(loc++; loc < length; loc++)
    {
        if(!esc)
        {
            if(src[loc] == strChar)
            {
                esc = true;
                src[loc] = '\0';
                dest[idx++] = src + loc + 1;
            }
            else if(src[loc] == splitChar)
            {
                src[loc] = '\0';
                loc++;
                while(src[loc] == splitChar && loc < length)
                    loc++;
                if(src[loc] == strChar)
                {
                    esc = true;
                    loc++;
                }
                if(loc < length)
                    dest[idx++] = src + loc;
            }
        }
        else
        {
            if(src[loc] == strChar)
            {
                if(src[loc - 1] == '\\')
                    continue;
                esc = false;
                src[loc++] = '\0';
                while(src[loc] == splitChar && loc < length)
                    loc++;
                if(loc < length)
                    dest[idx++] = src + loc;
            }
        }
    }
    return idx;
}

Ja det er lidt vigtigt.

Nogle compilere vil putte den første streng i readonly memory, så når man
forsøger at ændre strengen så ...

bertel >> Yup, havde jeg godt set :) Men det var desværre langt fra den eneste fejl... hehe. 4-5 dage med c++ og så har jeg allerede lært at lave SÅ mange fejl ;)

Kan man godt bruge malloc sammen med en char x[] ?

Never mind. Jeg afprøver det bare :)

nej

malloc og new kræver en pointer

calloc så ? :) eller...

. o O (Føler mig som en komplet idiot efter at jeg har kastet mig over c++, men denne gang gi'r jeg ikke op)

char x[] = "...............";

er et fast array (C beregner bare selv længden).

char *x;

er en pointer og kan bruges med new/malloc/calloc etc..

char *x = "...............";

er en pointer til en konstant streng

Så hvis jeg laver en char *x = malloc(1024) og modtager fra winsock, så er jeg nød til at kopiere det over i en char y[] for at kunne bruge min split funktion ?

Nej.

Fordi i det tilfælde peger pointeren på noget memory som godt kan opdateres.

Tilbage til tegnebrættet - tak for hjælpen alle :)