Array in der Mitte teilen

Laundry

Das Problem lieg in den 2 Zeilen:

char x[i] = ary[i];

char y[a] = ary[(a + (l / 2 + 1))];

David_pb

for(int i = 0; i!=(l / 2); i++) 
{ 
    char x[i] = ary[i]; // unsinn
}; 
for(int a = (l / 2 + 1); a!=l; a++) 
{ 
    char y[a] = ary[(a + (l / 2 + 1))]; // unsinn
};

Edit: Zu spät!

Laundry

Hm ich seh gerade die Eins (1) und L(l) sehe ja total gleich aus.

Ich markiere das L(l) mal dick!

for(int i = 0; i!=([b]l[/b] / 2); i++)
{
    char x[i] = ary[i];
};
for(int a = ([b]l[/b] / 2 + 1); a!=[b]l[/b]; a++)
{
    char y[a] = ary[(a + ([b]l[/b] / 2 + 1))];
};

CStoll

Erstens: Du hast immer noch nicht gesagt, was der Compiler zu meckern hat (beim näheren hinsehen tippe ich darauf, daß die beiden 'char' im inneren des for() stören - dort legst du neue lokale Variablen an, die mit deinen vorher definierten x und y nichts zu tun haben).

Zweitens: Im Array 'y' sind am Ende die ersten l/2 Zeichen leer und die nächsten l/2 Zeichen enthalten Datenmüll.

PS: Verwende doch statt char-Arrays lieber std::string

Laundry

Ach ich Depp ja stimmt die 2 neu angelegten Variablen waren das Problem, aber jetzt gehts auch.

*D*Evil

bool Degen(char ary[1024])
{
    int l = strlen(key);
    char x[1024] = "";
    char y[1024] = "";

    for(int i = 0; i!=(l / 2); i++)
    {
        char x[i] = ary[i];
    };
    for(int a = (l / 2 + 1); a!=l; a++)
    {
        char y[a] = ary[(a + (l / 2 + 1))];
    };
    cout << x << endl;
    cout << y << endl;
    return 0;
}

?!

void degen(const char* string, char* part_one, char* part_two, std::size_t max_size)
{
    std::size_t len = std::min(std::strlen(string) / 2, max_size - 1);
    std::strncpy(part_one, &string[0], len);
    std::strncpy(part_two, &string[len], len);
    part_one[len] = 0;
    part_two[len] = 0;
}

*D*Evil

aja ...

#include <algorithm> // std::max
#include <cstring> // std::strncpy
#include <iostream> // nur std::cout ... für Funktion unwichtig!

void degen(const char*, char*, char*, std::size_t);

int main()
{
    char arr[] = "Das ist ein Test!";
    char first[25];
    char last[43]; // ist egal wie groß der array ist ... solange entweder eine hälfte des strings reinpasst oder wenigstens max_size bei degen korrekt angegeben ist.
    degen(arr, first, last, 25);
    std::cout << arr << " => " << first << " | " << last << std::endl;
}

void degen(const char* string, char* part_one, char* part_two, std::size_t max_size)
{
    std::size_t len = std::min(std::strlen(string) / 2, max_size - 1);
    std::strncpy(part_one, &string[0], len);
    std::strncpy(part_two, &string[len], len);
    part_one[len] = 0;
    part_two[len] = 0;
}

...

Laundry

Hi,

danke ich werds ausprobieren, doch in der Zeile

std::size_t len = std::min(std::strlen(string) / 2, max_size - 1);

sagt er, dass ein "(" rechts falsch sein soll und das "::" nicht richtig ist

Und was soll die 25 genau bewirken beim übergeben?

*D*Evil

sagt er, dass ein "(" rechts falsch sein soll und das "::" nicht richtig ist

Dann setz mal ein

#undef min

vor den Code ... Hast wohl einen Header drin der min als Makro definiert hat. Markos sind scheiße!

Und was soll die 25 genau bewirken beim übergeben?

Nja scheinst den Code noch nicht ganz verstanden zu haben ... es geht darum, dass das die maximale Anzahl an Zeichen (inkl. Null-Terminierung) ist, die in beide Arrays(first, last) passen.

CStoll

soll ich auch mitmachen?

#include <string>
#include <iostream>

void degen(const std::string& str,std::string& one,std::string& two)
{
  size_t len = str.len()/2;
  one=str.substr(0,len);
  two=str.substr(len);
}

int main()
{
  std::string first,last;
  degen("Dies ist ein Test!",first,last);
  std::cout << arr << " => " << first << " | " << last << std::endl;
}

Laundry

Funktioniert ja jetzt danke

*D*Evil

pö... war nicht gesagt das normale std::strings genutzt werden dürfen

CStoll

(D)Evil schrieb:

pö... war nicht gesagt das normale std::strings genutzt werden dürfen

Es war auch nicht gesagt, daß man die Standard-Bibliothek nicht verwenden darf