Ajouter à la fin d'un tableau de Char en C++

Est-il une commande qui peut ajouter un tableau de char sur un autre? Quelque chose qui serait théoriquement fonctionne comme ceci:

//array1 has already been set to "The dog jumps "
//array2 has already been set to "over the log"

append(array2,array1);
cout << array1;

//would output "The dog jumps over the log";

C'est une question assez facile de la fonction de faire, je pense, je suis juste surpris de voir qu'il n'est pas intégré dans la commande.

*Modifier

Je devrais avoir été plus clair, je ne voulais pas dire la modification de la taille de la matrice. Si matrice1 a été fixé à 50 caractères, mais seulement à l'aide de 10 d'entre eux, vous auriez encore 40 caractères pour travailler avec. Je pensais à une commande automatique qui serait essentiellement le faire:

//assuming array1 has 10 characters but was declared with 25 and array2 has 5 characters
int i=10;
int z=0;    
do{
    array1[i] = array2[z];
    ++i;
    ++z;
}while(array[z] != '//assuming array1 has 10 characters but was declared with 25 and array2 has 5 characters
int i=10;
int z=0;    
do{
array1[i] = array2[z];
++i;
++z;
}while(array[z] != '\0');
');

Je suis assez sûr que la syntaxe de travail, ou quelque chose de similaire.

Il n'est pas unique et complet de type "array" en C++.

OriginalL'auteur Taylor Huston | 2012-03-31

arrays c++

13

Si vous n'êtes pas autorisé à utiliser C++de la classe string (qui est terrible d'enseignement C++ à mon humble avis), une matière première, un coffre-fort array version ressemblerait à quelque chose comme ça.
```
#include <cstring>
#include <iostream>

int main()
{
    char array1[] ="The dog jumps ";
    char array2[] = "over the log";
    char * newArray = new char[std::strlen(array1)+std::strlen(array2)+1];
    std::strcpy(newArray,array1);
    std::strcat(newArray,array2);
    std::cout << newArray << std::endl;
    delete [] newArray;
    return 0;
}
```
Ce qui vous assure d'avoir suffisamment d'espace dans le tableau que vous faites de la concaténation, sans en supposant que certains prédéfinis MAX_SIZE. La seule exigence est que vos chaînes sont null, ce qui est généralement le cas, sauf si vous êtes en train de faire un peu bizarre de taille fixe chaîne de piratage.

Modifier, d'un coffre-fort version avec le "assez d'espace tampon" hypothèse:
```
#include <cstring>
#include <iostream>

int main()
{
    const unsigned BUFFER_SIZE = 50;
    char array1[BUFFER_SIZE];
    std::strncpy(array1, "The dog jumps ", BUFFER_SIZE-1); //-1 for null-termination
    char array2[] = "over the log";
    std::strncat(array1,array2,BUFFER_SIZE-strlen(array1)-1); //-1 for null-termination
    std::cout << array1 << std::endl;
    return 0;
}
```
La question est de savoir sur l'ajout second tableau pour premier tableau, mais vous avez fait un nouveau tableau!
la question initiale a déclaré que deux des tableaux de char a dû être ajoutée. Il n'y a aucune exigence claire de la matrice de les réutiliser. Même avec cette exigence, c'est un bon réponse, parce que la "fixe taille de la mémoire tampon" n'est tout simplement pas faite en C++ (en réalité crue des tableaux en général). J'ai ajouté un plus sûr de la version avec les exigences.
Ok, vous avez édité votre réponse. mais la question de départ était: "Est-il une commande qui peut ajouter un tableau de char sur un autre?"

OriginalL'auteur KillianDS
4

Si vos tableaux sont des tableaux de caractères(ce qui semble être le cas), Vous avez besoin d'un strcat().

Votre tableau de destination doit avoir assez d'espace pour accueillir la annexé données.

En C++, Vous êtes beaucoup mieux d'utiliser std::string et puis vous pouvez utiliser std::string::append()

Je soupçonne donc la Plupart de la mission et les devoirs liés Q ont une étrange stipulations de ne pas utiliser les fonctions en C++ qui constituent la base de C++,& c'est la raison pour laquelle je fournis les deux variantes.strcat() ou strncat() est ce que vous devriez utiliser dans ce cas.Consultez le lien pour les détails d'utilisation.

OriginalL'auteur Alok Save
1

Il n'y a pas de commande intégrée pour cela que parce que c'est illégal. Vous ne pouvez pas modifier la taille d'un tableau une fois déclarée.

Ce que vous cherchez est soit std::vector pour simuler un tableau dynamique, ou mieux encore, une std::string.
```
std::string first ("The dog jumps ");
std::string second ("over the log");
std::cout << first + second << std::endl;
```
Vous ne pouvez pas modifier la taille d'un tableau avant il déclaré. La taille est du type. Ce que vous dites, c'est comme dire que "vous ne pouvez pas modifier un int à un flotteur après elle est déclarée".
Un tableau de type sans taille est incomplète, mais il est encore un type. Toutefois, dans ce cas, vous pouvez modifier la taille de l'déclaré une fois 😀 . Semble assez clair que Luchian est de dire: bien défini l'objet array est immuable la taille.
Vous avez raison, j'ai oublié que vous en fait, déclarer un type incomplète avec extern, comme dans extern int a[];. Bon point. (Mais vous ne pouvez pas modifier de la taille, seulement spécifiez. Qui est, vous pouvez simplement différer la prise de décision.)

OriginalL'auteur Luchian Grigore

Vous devriez avoir suffisamment d'espace pour array1 tableau et utiliser quelque chose comme strcat contacter array1 à array2:

char array1[BIG_ENOUGH];
char array2[X];
/* ......             */
/* check array bounds */
/* ......             */

strcat(array1, array2);

OriginalL'auteur deepmax

Vous devez vous connecter pour publier un commentaire.