aucun constructeur approprié existe pour convertir de “test *” à “test”, un constructeur,un

Je suis nouveau sur c++ et je vais avoir des difficultés avec le constructeur et les classes. Donc, voici mon fichier d'en-tête:

#pragma once
#include <string>
using namespace std;
class test
{

    private:
    string name;
    int number;

public:

    test();
    test(string i,int b);
};

C'est un fichier cpp:

#include "test.h"
#include <string>
using namespace std;


test::test(){}

test::test(string i,int b){
    this->name=i;
    this->number=b;
}

maintenant, quand j'essaie d'appeler

test t=new test("rrr",8);

J'obtiens:

1   IntelliSense: no suitable constructor exists to convert from "test *" to "test"

Alors, quelle est la chose avec des classes ayant * dans leur nom ( par exemple, les classes sans .fichier cpp n'ont pas astérix, tous les autres le font)? Et que dois-je faire de mal?

OriginalL'auteur klo | 2013-03-26

c++constructor instance object pointers

24

J'imagine que vous êtes en provenance d'un Java/C# arrière-plan. t n'est pas un type de référence ici, c'est un type de valeur. new retourne un pointeur vers un objet. Si vous avez besoin des éléments suivants:
```
test t = test("rrr", 8);
test t("rrr", 8);
test *t = new test("rrr", 8);
```
Si vous n'êtes pas encore familier avec les pointeurs, puis définitivement n'utilisez pas le dernier! Mais la compréhension de la sémantique des pointeurs est assez critique; je vous recommande la lecture du chapitre correspondant(s) dans votre manuel...

Nice, votre réponse est beaucoup mieux que le mien 🙂 +1
tnx beaucoup. u l'aurez deviné, j'ai fait de la programmation en java et c# im si je peu du mal avec le c++ 🙂 ....
Si vous essayez de programmer en C++ comme vous programmé en Java vous permettra de faire beaucoup d'erreurs. Ils ne sont pas très similaire à tous.

OriginalL'auteur Oliver Charlesworth
5

Alors, quelle est la chose avec des classes ayant une "*" dans leur nom ( par exemple, les classes sans .fichier cpp n'ont pas astérix, tous les autres ne)???

Vous avez certainement besoin de savoir sur les pointeurs. test * et test sont deux totalement différents types en C++. Voici deux variables avec ces types:
```
test t;
test* p;
```
Ici, t a type test, et p type test*. Nous décrivons test* comme "pointeur vers test".

Vous pouvez souvent penser à un pointeur comme étant l'adresse mémoire d'un objet. Ainsi, dans p, puisque c'est un pointeur, on peut stocker l'adresse de la mémoire de t, qui est un test. Pour obtenir l'adresse d'un objet, nous utilisons le unaire & opérateur, comme suit:
```
test t;
test* p = &t;
```
Noter que t est un test objet. Vous n'avez pas besoin de dire new test(). C'est là que le C++, qui diffère des autres langues que vous pourriez avoir utilisé, comme C# et Java. Au-dessus de code C++, t est un test objet.

Cependant, vous peut créer des objets avec new test(), alors quelle est la différence?

test t; crée un test objet automatique de la durée de stockage. Cela signifie qu'il est détruit à la fin de son champ d'application (souvent la fonction est déclarée à l'intérieur).

new test() crée un test objet dynamiques de la durée de stockage. Cela signifie que vous avez à détruire l'objet manuellement, sinon, vous avez une fuite de mémoire. Cette expression renvoie un pointeur et donc, vous pouvez initialiser un pointeur sur un objet avec:
```
test* p = new test();
```
Alors maintenant, passons à votre problème:
```
test t=new test("rrr",8);
```
Nous savons maintenant que new test("rrr", 8) retourne un pointeur vers test (un test*). Cependant, vous essayez de l'attribuer à un test objet. Vous ne pouvez tout simplement pas faire cela. L'un d'eux est une adresse et l'autre est un test. Donc le compilateur dit "pas de constructeur approprié existe pour convertir test * à test." De sens maintenant, n'est-ce pas?

Au lieu de cela, vous devriez préférer l'utilisation automatique de la durée de stockage. Utilisez uniquement new si vous avez vraiment, vraiment besoin. Il suffit donc de ne:
```
test t("rrr", 8);
```
OriginalL'auteur Joseph Mansfield
2
```
test t=new test("rrr",8);
```
doit être
```
// v
test* t=new test("rrr",8);
```
Alors, quelle est la chose avec des classes ayant une "*" dans leur nom

* est utilisé pour indiquer un pointeur, il n'est pas dans le nom de la classe. Mais c'est un grand sujet, de sorte que vous devriez faire un peu de recherche sur ce.

OriginalL'auteur Kiril Kirov
1

* n'est pas une partie du nom, c'est un modificateur indiquant que l'objet est un pointeur. Un pointeur est une variable contenant l'adresse d'un lieu de mémoire, où l'objet réel est stockée. Quelques notions de base:
```
int i = 5;
int * pI = &i;
```
int * pI signifie, que vous voulez déclarer un pointeur à l'endroit de la mémoire, où un int est tenue. &i signifie, que vous souhaitez récupérer un pointeur vers une variable. Alors maintenant, pI est titulaire d'adresse dans la mémoire, où i est stockée. Maintenant, vous pouvez de déréférencement un pointeur - pour la valeur du pointeur:
```
int j = *pI;
```
Maintenant vous dire au compilateur qu'il doit aller à l'adresse pointée par pI et récupérer son contenu (puisque pI est un pointeur sur int, le compilateur suppose, qu'il y a un int y).

Maintenant, revenons à votre exemple. new opérateur alloue dynamiquement la mémoire pour un objet, donc:
```
new test("rrr", 8);
```
résultats dans l'allocation de mémoire pour la classe de test, en appelant son constructeur avec paramètres "rrr" et les 8 et retourner un pointeur vers la mémoire allouée. C'est pourquoi vous ne pouvez pas attribuer à test variable: nouvel opérateur dans ce cas renvoie une test *.

Essayez ce code:
```
test * t = new test("rrr", 8);
```
OriginalL'auteur Spook
0

Vous ne définissez pas t comme un pointeur:
```
test* t=new test("rrr",8);
```
Ou tout simplement
```
test t = test("rrr",8);
```
OriginalL'auteur bash.d
0
```
T* t = new T;
//    ^^^
```
Lorsque la nouvelle est utilisé dans cette construction de l'objet, il dénote la création d'un pointeur. Ce que font alloue dynamiquement de la mémoire qui, je suis sûr que tu ne voulais pas faire. Plutôt, typique de la pile alloué de construction de l'objet se fait tout simplement comme ceci:
```
T t;
```
Même si vous avez l'intention sur la création d'un pointeur et allocation de la mémoire, vous l'avez fait dans le mauvais sens. Un pointeur est créé avec la * symbole, qui vous manquait dans votre code. Deuxièmement, lorsque vous avez fini d'utiliser la mémoire que vous avez créé, vous devez vous rappeler de delete/delete[] votre code. delete[] est utilisé sur des tableaux alloués dynamiquement. Donc, c'est comment il serait à la recherche de votre pointeur:
```
delete t;
```
OriginalL'auteur 0x499602D2

Vous devez vous connecter pour publier un commentaire.