problème de conversion std::string a const wchar_t*

Version imprimable

27/05/2018, 17h08
panthere noire

problème de conversion std::string a const wchar_t*
Bonjours,

Je sui confronter a un problème qui semble être lier a l'unicode ou ACII,

l
Code:

1 2 3 4 5 6 int main() { std::wstring test=L"data"; int Ret = SetProcessPriority(test.c_str(),BELOW_NORMAL_PRIORITY_CLASS); }
il existerait des variantes qui devrais remplacer ce problème SetProcessPriorityA et SetProcessPriorityW

Que j'utilise c_str() ou les diferrente macro(fonction SetProcessPriority ,SetProcessPriorityA ,SetProcessPriorityW) non n'y change rien.

Je ne sais pas en quoi ça compile ( enfin sou code block) ou si c' est juste le format du fichier (main.cpp) pour le format acii ou unicode ou un paramètre doit être passer à gcc ?
Code:

1 2 error: invalid conversion from 'const wchar_t*' to 'PWSTR {aka wchar_t*}' [-fpermissive]|
Cordialment,
27/05/2018, 17h29
foetus

Effectivement, un wstring à la place d'une chaîne de caractères de type LPTSTR (et donc LPWSTR en Unicode) doit nécessiter des tests et de la documentation pour voir si le "mariage" prend :mrgreen:

Mais ton problème est un problème purement C++ :mrgreen: : constness.
En gros la méthode wstring::c_str() retourne une chaîne de caractères constante (la classe refuse que tu modifies cette chaîne directement, via l'emplacement mémoire) mais le compilateur ne l'accepte pas parce que la fonction/ macro SetProcessPriority peut la modifier.

basic_string::c_str :

Citation:

A program shall not alter any of the characters in this sequence.

const_cast<>() :whistle:
27/05/2018, 18h15
Bousk

C'est un des rares cas où const_cast est utile, parce que ces APIs pour quelconque raison prennent des (w)char(_t)* et non des const (w)char(_t)* mais ne modifient généralement pas la chaîne pour autant.. (à vérifier dans la doc cela dit..)
27/05/2018, 18h40
panthere noire

Je ne connaissais pas cette méthode et n'est pas documentée dans les 2 livres que j'ustilises. ça pourrai servir pour la faq ;)

const_cast<>() :whistle:

je vais voir comment on s'en sert parce que sans doc c'est plus compliquer

merci pour vos réponses:ccool:

Bonjour,

Pour couper court à toute vilaine pratique, panthere noire nous a fourni ladite fonction sur le chat, ce n'est pas une fonction pré-existante mais une fonction qu'il code :
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 void SetProcessPriorityA(PWSTR ProcessName, int Priority) { PROCESSENTRY32 proc32; HANDLE hSnap; //if (hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0)); hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0); if (hSnap == INVALID_HANDLE_VALUE) { } else { proc32.dwSize = sizeof(PROCESSENTRY32); while ((Process32Next(hSnap, &proc32)) == TRUE) { std::string T1= proc32.szExeFile; //std::string T2= ProcessName; /* if (_wcsicmp(proc32.szExeFile, ProcessName) == 0) { HANDLE h = OpenProcess(PROCESS_SET_INFORMATION ,TRUE, proc32.th32ProcessID); SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS); CloseHandle(h); */ } } CloseHandle(hSnap); }
Donc, comme dragonjoker59 et moi-même te l'avons conseillé, utilise à bon escient le type TCHAR afin de t'affranchir de la contrainte A/W :

Code:

using tstring = std::basic_string<TCHAR>;

et passe un const tstring & à ta fonction à la place du PWSTR (=wchar_t* là où test.c_str() est de type const wchar_t*), ainsi que sur la ligne std::string T1= proc32.szExeFile;.

Puis utilise la macro TEXT() pour l'appeler :

Code:

int Ret = SetProcessPriority(TEXT("data"), BELOW_NORMAL_PRIORITY_CLASS);

J'ai fait les modifications vous m'avez proposé,enfin si j'ai rien rater :?

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
53
 
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include  <fstream>
#include <tchar.h>
#include "listing_process.hpp"
#include "setpriority.hpp"
using namespace std;
 
//typedef char* PSTRING;
using tstring = std::basic_string<TCHAR>;
 
//void SetProcessPriorityW(PWSTR ProcessName, int Priority)
void SetProcessPriority(const tstring &, int Priority)
{
    PROCESSENTRY32 proc32;
 
    HANDLE hSnap;
 
    //if (hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
    hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap == INVALID_HANDLE_VALUE)
    {
 
    }
    else
    {
        proc32.dwSize = sizeof(PROCESSENTRY32);
        while ((Process32Next(hSnap, &proc32)) == TRUE)
        {
 
            const tstring & T1= proc32.szExeFile;
            //std::string T2= ProcessName;
  /*          if (_wcsicmp(proc32.szExeFile, ProcessName) == 0)
            {
                HANDLE h = OpenProcess(PROCESS_SET_INFORMATION ,TRUE, proc32.th32ProcessID);
                SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS);
                CloseHandle(h);
*/        }
    }
        CloseHandle(hSnap);
}
 
 
 
 
int main()
{
	SetProcessPriority(TEXT("data"),BELOW_NORMAL_PRIORITY_CLASS);
	return 0;
}

Code:

1
2
3
4
5
6
7
8
9
 
||=== Build: Debug in ControlProcess (compiler: GNU GCC Compiler) ===|
|14| error: expected nested-name-specifier before 'tstring'|
|17|error: 'tstring' does not name a type|
||In function 'void SetProcessPriority(const int&, int)':|
|35|error: 'tstring' does not name a type|
||In function 'int main()':|
|58|error: invalid conversion from 'const char*' to 'int' [-fpermissive]|
|17|note:   initializing argument 1 of 'void SetProcessPriority(const int&, int)'|

27/05/2018, 19h43
Invité

using alias = type; c'est du C++11. Soit tu actives l'option, soit tu utilises typedef à la place.
27/05/2018, 20h08
panthere noire
Citation:

Envoyé par Winjerome

using alias = type; c'est du C++11. Soit tu actives l'option, soit tu utilises typedef à la place.
Code:

1 2 typedef tstring = std::basic_string<TCHAR>;
Code:

error: 'tstring' does not name a type|

Quand à : alias : j'ai bien tenté de mettre les options mai le problème reste le même:?
27/05/2018, 20h14
Invité

:roll: typedef specifier

Code:

typedef std::basic_string<TCHAR> tstring;
27/05/2018, 20h26
panthere noire

A ben forcement du bon coter sa marche mieux :bug:

Merci beaucoup :ccool:

je croit que sa coince toujours:

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
53
 
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include  <fstream>
#include <tchar.h>
#include "listing_process.hpp"
#include "setpriority.hpp"
#include <string.h>
using namespace std;
 
//typedef char* PSTRING;
 
 
//typedef tstring = std::basic_string<TCHAR>;
typedef std::basic_string<TCHAR> tstring;
//void SetProcessPriorityW(PWSTR ProcessName, int Priority)
void SetProcessPriority(const tstring &, int Priority)
{
    PROCESSENTRY32 proc32;
 
    HANDLE hSnap;
 
    //if (hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0));
    hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap != INVALID_HANDLE_VALUE)
    {
        proc32.dwSize = sizeof(PROCESSENTRY32);
        while ((Process32Next(hSnap, &proc32)) == TRUE)
        {
 
           // const tstring & T1= proc32.szExeFile;
            //std::string T2= ProcessName;
 
            if (_wcsicmp(proc32.szExeFile, tstring) == 0)
            {
                HANDLE h = OpenProcess(PROCESS_SET_INFORMATION ,TRUE, proc32.th32ProcessID);
                SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS);
                CloseHandle(h);
                cout << "confirmer : " << proc32.szExeFile << endl;
            }
        }
    }
        CloseHandle(hSnap);
}
 
 
int main()
{
SetProcessPriority(TEXT("Calculator.exe"),BELOW_NORMAL_PRIORITY_CLASS);
    return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
 
||=== Build: Debug in ControlProcess (compiler: GNU GCC Compiler) ===|
main.cpp||In function 'void SetProcessPriority(const tstring&, int)':|
main.cpp|35|error: expected primary-expression before ')' token|
setpriority.cpp||In function 'void MePrio()':|
setpriority.cpp|16|warning: unused variable 'dwError' [-Wunused-variable]|
setpriority.cpp|16|warning: variable 'dwPriClass' set but not used [-Wunused-but-set-variable]|
setpriority.cpp||In member function 'bool CPriority::SetChangePriorityID(unsigned int&)':|
setpriority.cpp|42|warning: no return statement in function returning non-void [-Wreturn-type]|
||=== Build finished: 1 error(s), 3 warning(s) (0 minute(s), 0 second(s)) ===|

edit:
j'ai verfier pour la "(" mai je pense que c est la variable qui est en cause:weird:

27/05/2018, 21h28
Invité

Code:

if (_wcsicmp(proc32.szExeFile, tstring) == 0)

tstring est un alias du type std::basic_string<TCHAR>, ce n'est pas une variable.
Et si tu as ajouté l'inclusion <string.h> pour ça t'es tombé à côté. std::basic_string se situe dans l'entête <string>.

Il faudra également penser à retourner une valeur dans la fonction membre CPriority::SetChangePriorityID, ou changer son retour en void, ce qui aurait plus de sens vu son nom.
27/05/2018, 21h33
foetus

À supprimer ce using namespace std; et à ajouter le nom du premier paramètre ;)

Voici ce que sa donne ,code compilable a ce stade .

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
 
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include  <fstream>
#include <tchar.h>
#include "listing_process.hpp"
#include "setpriority.hpp"
 
//using namespace std;
typedef std::basic_string<TCHAR> tstring;
void SetProcessPriority(const tstring & T1, int Priority)
{
    PROCESSENTRY32 proc32;
    HANDLE hSnap;
 
    hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap != INVALID_HANDLE_VALUE)
    {
        proc32.dwSize = sizeof(PROCESSENTRY32);
        while ((Process32Next(hSnap, &proc32)) == TRUE)
        {
            if (proc32.szExeFile == T1)
            {
                HANDLE h = OpenProcess(PROCESS_SET_INFORMATION ,TRUE, proc32.th32ProcessID);
                SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS);
                std::cout << "confirmer :: " << h << ": T1 : " << T1
                <<  " : " << proc32.szExeFile << std::endl;
                CloseHandle(h);
            }
        }
    }
        CloseHandle(hSnap);
}
 
 
int main()
{
    SetProcessPriority(TEXT("Calculator.exe"),BELOW_NORMAL_PRIORITY_CLASS);
    return 0;
}

Merci a tous pour vos conseil je pense que cela va surement servir a d'autre personne.

Il doit au moins te rester un avertissement :

Code:

1
2
3
4
main.cpp: In function 'void SetProcessPriority(const tstring&, int)':
main.cpp:13:49: warning: unused parameter 'Priority' [-Wunused-parameter]
 void SetProcessPriority(const tstring & T1, int Priority)
                                                 ^~~~~~~~

;)

Bon j'essaye d'en faire un classe mai la il me demande du const int& ou il ne peux y avoir que du char .... :mur:
Quand c est pas en plus qu'il ne reconnaît pas la méthode public..:koi:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <iostream>
#include <fstream>
#include <tchar.h>
#include "listing_process.hpp"
#include "setpriority.hpp"
typedef std::basic_string<TCHAR> tstring;
 
int main()
{
 
    std::string Tmp="Calculator.exe";
    CPriority CpTarget;
    CpTarget.mSetPriority(TEXT(Tmp));
    //SetProcessPriority(TEXT("Calculator.exe"),BELOW_NORMAL_PRIORITY_CLASS);
    return 0;
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
#ifndef PRIOPROC
#define PRIOPROC
#include <string>
#include <iostream>
 
#include <stdio.h>
#include <windows.h>
#include <tlhelp32.h>
#include <tchar.h>
#include <vector>
 
class CPriority{
public:
    CPriority();
    ~CPriority();
 
    void mSetPriority(const &tstring);
    void MePrio();
private:
    void SetProcessPriority(const &tstring , int Priority);
};
#endif

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
 
include "setpriority.hpp"
typedef std::basic_string<TCHAR> tstring;
//using namespace std;
/*constructeur destructeur*/
CPriority::CPriority(){}
CPriority::~CPriority(){}
/*-------------------------*/
 
void SetProcessPriority(const tstring & T1, int Priority)
{
    PROCESSENTRY32 proc32;
    HANDLE hSnap;
    hSnap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
    if (hSnap != INVALID_HANDLE_VALUE)
    {
        proc32.dwSize = sizeof(PROCESSENTRY32);
        while ((Process32Next(hSnap, &proc32)) == TRUE)
        {
            if (proc32.szExeFile == T1)
            {
                HANDLE h = OpenProcess(PROCESS_SET_INFORMATION ,TRUE, proc32.th32ProcessID);
                SetPriorityClass(h, BELOW_NORMAL_PRIORITY_CLASS);
                std::cout << "confirmer :: " << h << ": T1 : " << T1
                <<  " : " << proc32.szExeFile << std::endl;
               // RetPrio = true;
                CloseHandle(h);
            }
        }
    }
        CloseHandle(hSnap);
}
 
void CPriority::mSetPriority(const &Ref_tstring){
  //SetProcessPriority(Ref_tstring,BELOW_NORMAL_PRIORITY_CLASS);
  SetProcessPriority(Ref_tstring,BELOW_NORMAL_PRIORITY_CLASS);
}

resulta:

Code:

1
2
3
4
5
6
7
8
9
 
||=== Build: Debug in ControlProcess (compiler: GNU GCC Compiler) ===|
setpriority.cpp||In function 'void MePrio()':|
setpriority.cpp|73|warning: variable 'dwPriClass' set but not used [-Wunused-but-set-variable]|
main.cpp||In function 'int main()':|
main.cpp|16|error: no matching function for call to 'CPriority::mSetPriority(std::__cxx11::string&)'|
setpriority.hpp|17|note: candidate: void CPriority::mSetPriority(const int&)|
setpriority.hpp|17|note:   no known conversion for argument 1 from 'std::__cxx11::string {aka std::__cxx11::basic_string<char>}' to 'const int&'|
||=== Build finished: 1 error(s), 1 warning(s) (0 minute(s), 0 second(s)) ===|

28/05/2018, 19h46
Invité

À un moment ou un autre, il va falloir lire un bon cours et assimiler les bases...

Code:

void SetProcessPriority(const &tstring , int Priority);

Le type tstring n'a rien à faire à droite. Ton compilateur considère dès lors qu'il s'agit du nom du paramètre et qu'il manque le type, il prend donc int par défaut.
Et pense également à le définir avant de l'utiliser dans ton entête.
29/05/2018, 00h18
panthere noire

Merci, pour ce qui est du court c est pas sa qui manque mai plutôt la concentration.
C est une macro C ce qui pose problème quand on veux l’insérer dans une classe.
le seul moyen que j'ai trouver temporairement c est de mettre la fonction "que" dans le *.cpp
avec un commentaire dans le *.hpp pas très propre mai bon a défaut on va faire que sa tourne et ensuite on va optimiser (surtout le mec derriere le clavier:lol:)
Merci pour votre patience :ccool: