Discussion :

[panthere noire]

Bonjours,

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

l

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
error: invalid conversion from 'const wchar_t*' to 'PWSTR {aka wchar_t*}' [-fpermissive]|

Cordialment,

[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

Mais ton problème est un problème purement C++ : 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 :

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

const_cast<>()

[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..)

[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<>()

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

merci pour vos réponses

[Invité]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[panthere noire]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)'|

[Invité]

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

[panthere noire]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

typedef specifier

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

typedef std::basic_string<TCHAR> tstring;

[panthere noire]

A ben forcement du bon coter sa marche mieux

Merci beaucoup

[panthere noire]

je croit que sa coince toujours:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[Invité]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

            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.

[foetus]

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

[panthere noire]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[Invité]

Il doit au moins te rester un avertissement :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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)
                                                 ^~~~~~~~

[panthere noire]

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 ....
Quand c est pas en plus qu'il ne reconnaît pas la méthode public..

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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)) ===|

[Invité]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[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)
Merci pour votre patience