Comment utiliser (void* data)

Version imprimable

Bonjour,

je voudrais récupérer le contenu d'une méthode :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
void init()
{
	static const void* type =
	{
		static_cast<void*>(new std::string("it's easy to break stuff like this!"))
	};
 
	test(&type);
}
 
void test(void* vp)
{
	//void* vp = static_cast<void*>(new std::string("it's easy to break stuff like this!"));
	std::string* sp = static_cast<std::string*>(vp);
	std::string monType = *sp;
	String^ type = gcnew String(monType.c_str());
	Console::Write(type);
}

mais je récupère une valeur vide quand je lance init()

Merci

En C/ C++, le type void* est pour faire la généricité :mrgreen:
Donc, pour le passage de paramètres, il ne faut pas passer 1 variable de type void* mais l'adresse/ 1 pointeur d'1 variable normalement, et avoir 1 énumération pour savoir quel type on passe.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
#include <iostream>
#include <string>
 
#include <cstdlib>
 
 
typedef enum e_test_type {
    TEST_TYPE_STING = 0,
    TEST_TYPE_COORD
} t_test_type;
 
 
typedef struct s_coord {
    s_coord(size_t input_x=0, size_t input_y=0) : x(input_x), y(input_y) {}
    s_coord(const s_coord& other) : x(other.x), y(other.y) {
        std::cout << "s_coord - copy constructor" << std::endl;
    }
 
    size_t x, y;
} t_coord;
 
 
void func_test(void* vp, t_test_type type) {
    if (type == TEST_TYPE_STING) {
        std::string* str  = (std::string*) vp;
        std::string& rstr = *((std::string*) vp);
 
        std::cout << "func_test: " << std::endl << "*) " << (*str) << std::endl << "*) " << rstr << std::endl;
    } else /* if (type == TEST_TYPE_COORD) */ {
        t_coord* coord = static_cast<t_coord*>(vp);
        t_coord ccoord = *( static_cast<t_coord*>(vp) );
 
        std::cout << "func_test: " << std::endl << "*) " << coord->x << ", " << coord->y << std::endl << "*) " << ccoord.x << ", " << ccoord.y << std::endl;
    }
}
 
 
/*****************************************************************************/
/***********************************  Main  **********************************/
/*****************************************************************************/
 
int main(int argc, char** argv)
{
    std::string str = "it's easy to break stuff like this!";
    t_coord coord(15, 57);
 
    func_test(&str,   TEST_TYPE_STING);
    func_test(&coord, TEST_TYPE_COORD);
 
 
    return EXIT_SUCCESS;
}

28/02/2021, 10h00
pol2095

Merci.

Non cela fonctionne :mrgreen:

Mais ce n'est plus 1 type std::string, mais char*. Tu ne peux pas caster 1 char* vers 1 std::string (:koi: peut-être avec 1 reinterpret_cast mais c'est ultra plantogène).
Ensuite la méthode .c_str() retourne 1 chaîne constante : donc il faut soit retirer le cont (avec 1 const_cast ou 1 cast C) soit passer 1 paramètre const void* (ce qui peut-être gênant)
Enfin, il faudrait sûrement faire 1 copie du retour de la méthode .c_str() pour ne pas avoir de suprises. En C, on passe par strcpy/ strncpy/ petites sœurs. En C++/ C# je te laisse chercher.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 // ... typedef enum e_test_type { TEST_TYPE_STING = 0, TEST_TYPE_CHAR, TEST_TYPE_COORD } t_test_type; // ... void func_test(void* vp, t_test_type type) { // ... } else /* if (type == TEST_TYPE_CHAR) */ { char* cstr = static_cast<char*>(vp); std::cout << "func_test: " << std::endl << *str << std::endl; } } int main() { std::string ns("test"); char* myns = const_cast<char*>( ns.c_str() ); func_test(myns, TEST_TYPE_CHAR); return 0; }

28/02/2021, 10h53
pol2095

C'est bon

const char* perd la valeur

en recréant :

Code:

std::string* str = new std::string(mystr);

ça fonctionne, merci.