ich hab ein Problem mit dem folgenden Code:

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;
}

Damit will ich bezwecken, dass ein Array in der Mitte geteilt wird und beide Teile einzeln vorliegen. Noch als Info: der Array hat immer eine gerade Zahl.

Danke für eure Hilfe.

Zweitens: Schon beim ersten Überfliegen des Quelltextes fällt auf, daß du keine Null-Terminatoren in die Ziel-Arrays eingebaut hast.

PS: Und die Angabe 'char array[1024]' beim Parameter hat keinen Einfluß darauf, wie groß das übergebene char-Array tatsächlich werden kann.

char x[i] = ary[i];

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

Edit: Zu spät!

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))];
};

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

?!

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;
}

#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;
}

...

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?

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.

#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;
}

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