CHAR konvertieren in WCHAR

Okay, jeder hat mal angefangen, aber wozu schreibst du die Funktion, wenn du sie gar nicht aufrufst?
Außerdem wird ein Zeiger zurückgegeben, dein KeyNameBuffer ist ein Array mit genau einem Element.
Ferner solltest du Variablen so lokal wie möglich halten (also keine globalen Variablen benutzen).

WCHAR* charToWide(const char* in)
{
    WCHAR *KeyNameBuffer = malloc((strlen(in) + 1) * sizeof(WCHAR));
    if(KeyNameBuffer)
        MultiByteToWideChar(CP_ACP, 0, in, strlen(in) + 1, KeyNameBuffer, strlen(in) + 1); // insgesamt 3 strlen-Aufrufe, besser vorher speichern (siehe 1. Seite)
    return KeyNameBuffer;
}

int main()
{
    const char* src = "irgendwas";
    wchar_t* dst = charToWide(src);
    if(dst)
    {
        // irgendwas  mit dst machen
        free(dst); // Freigabe nicht vergessen
    }
    return 0; // in C wohl nötig
}

Nachtrag: Verwende auch besser kein gets, es gibt bessere Alternativen, siehe fgets.

der_Ronny

bitte schaut euch nochmal den ZULETZT von mir geposteten Code an und bessert dann das aus, was falsch ist - den Funktionsaufruf bringe ich anscheinend nicht hin - irgendwas mach ich trotz vielem Lesen und Recherchieren falsch....

Es wäre für mich viel einfacher, wenn bei einem Vorschlag von eurer Seite einfach mein gesamter Code mit den Änderungen von dir/euch gepostet wird - vielleicht kapier ichs dann - i hope so

PS: der Code muß auf jeden Fall C und nicht C++ sein....thx

Wir helfen gerne.
Wir machen aber nicht deine Arbeit.

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include "reghide.h"

WCHAR* charToWide(const char* Gesamtschluessel)
{
WCHAR *KeyNameBuffer = malloc((strlen(Gesamtschluessel) + 1) * sizeof(WCHAR)); // Dieses KeyNameBuffer hat mit dem KeyNameBuffer ein paar Zeilen tiefer nichst zu tun (außer Namensgleichheit).
MultiByteToWideChar(CP_ACP, 0, Gesamtschluessel, strlen(Gesamtschluessel) + 1, KeyNameBuffer, strlen(Gesamtschluessel) + 1);
return KeyNameBuffer;
}

WCHAR KeyNameBuffer[] = L"";  // Hier ist Platz für 0 Zeichen
// Ausserdem kannst du einem Array keine Adresse zuweisen. 
// Nimm einen Pointer, wie in deiner Funktion oben.

char Teilschluessel[] = { "\\Registry\\Machine\\SOFTWARE\\Wow6432Node\\Classes\\CLSID\\" };
char Gesamtschluessel[] = { "" }; // Hier ist Platz für 0 Zeichen

int main ()
{
char Schluesselname[40];

printf("Bitte geben Sie den Registryschluessel ein: \n");
gets(Schluesselname); // besser fgets(Schluesselname,39,stdin) nehmen. 
printf("\n\n---------------------------------------------------\n");
printf("Schluesselname:                  %s\n",Schluesselname);
printf("Teilregistrierungsschluessel:    %s\n",Teilschluessel);
strcpy (Gesamtschluessel, Teilschluessel); // Wie gesagt ist in Gesamtschluessel Platz für 0 Zeichen 
strcat (Gesamtschluessel, Schluesselname);  // DA passt nichts mehr rein.
printf("Gesamtregistrierungsschluessel:  %s\n",Gesamtschluessel);

wprintf(L"\n\nWCHAR:  %s\n",KeyNameBuffer);

// Hier fehlt irgendwo der Aufruf von deiner Funktion charToWide()
// KeyNameBuffer = charToWide(Gesamtschluessel); // oder so
// geht aber nur, wenn KeyNameBuffer  ein Pointer ist.

printf("--------------------------------------------------- \n");

wprintf(L"\n\nWCHAR:  %s\n",KeyNameBuffer);

system("PAUSE");
return 0;
}

Ob das ganze MultibyteWidechar so in Ordnung ist, kann ich dir nicht sagen.
Link: fgets

Hast du ein gutes Buch, um C zu lernen? Du solltest dir noch einmal das Kapitel über Zeiger und Arrays anschauen, wann brauchst du einen Zeiger, wann ein Array?
Um Zeichenketten hintereinander zu hängen, bietet sich eine kleine Hilfsfunktion an:

char* Concatenate(const char* fst, const char* sec)
{
    size_t fstlen = strlen(fst);
    size_t seclen = strlen(sec);
    char* ret = malloc(fstlen+seclen+1);
    if(ret)
    {
        strcpy(ret, fst);
        strcpy(ret+fstlen, sec);
    }
    return ret;
}
wchar_t* charToWide(const char* src) // von der ersten Seite dieses Threads
{
    size_t len = strlen(src);
    wchar_t* dst = malloc((len+1)*sizeof(wchar_t));
    if(dst)
    {
        if(!MultiByteToWideChar(CP_ACP, 0, src, len, dst, len))
        {
            free(dst);
            dst = 0;
        }
    }
    return dst;
}

Und die main (unvollständig):

int main ()
{
    WCHAR* KeyNameBuffer;
    char Teilschluessel[] = { "\\Registry\\Machine\\SOFTWARE\\Wow6432Node\\Classes\\CLSID\\" };
    char* Gesamtschluessel;

    char Schluesselname[40];

    printf("Bitte geben Sie den Registryschluessel ein: \n");
    fgets(Schluesselname, sizeof(Schluesselname), stdin);

    // ?
}

Den letzten Teil hätte ich dir jetzt auch noch hinschreiben können, tu dir aber selbst einen Gefallen und probiere es selbst zu lösen.

der_Ronny

pfu - nein versteh ich schon - ich will ja auch nicht, daß ihr meine Arbeit macht, nur bin ich anscheinend jetzt endgültig geistig ausgestiegen.
Dachte nicht, daß es so schwer wäre, einen CHAR in einen WCHAR zu konvertieren...

Belli

der_Ronny schrieb:

Dachte nicht, daß es so schwer wäre, einen CHAR in einen WCHAR zu konvertieren...

Ist es ja auch nicht. Es ist allerdings vielleicht nicht der beste Einstieg, wenn man offensichtlich blutiger Anfänger ist. Da sollte man erst mal lernen, welche Datentypen es gibt, was eine Funktion ist, und wie man sie benutzt/aufruft, was ein Zeiger ist und wofür man ihn einsetzt - einfach erst mal ein paar grundlegende Dinge.

Ich kann mir überhaupt nicht vorstellen, wozu man als blutiger Anfänger WCHAR - Zeichenketten benötigt, vor allen Dingen nicht in einem Konsolenprogramm ...

der_Ronny

Belli schrieb:

Ich kann mir überhaupt nicht vorstellen, wozu man als blutiger Anfänger WCHAR - Zeichenketten benötigt, vor allen Dingen nicht in einem Konsolenprogramm ...

Wie gesagt benötige ich dies als Weiterführung zu einem größeren Projekt, welches jetzt nicht unbedingt auf C basiert. Die WCHAR Zeichenkette wird in weiterer Folge einfach von einem weiteren C-Progrämmchen verwendet, welches ca. 10% vom gesamt Projekt ausmacht.

Der Rest hat nichts mehr mit C zu tun - eben deshalb dachte ich, es ihr könntet mir dabei behilflich sein, OHNE daß ich mich nun wochenlang mit C beschäftige, nur um diese Zeichenkette nutzen zu können.

Belli

Okay, ich hab Dir mein obiges C++ Beispiel mal nach C umgeschrieben:

#include <windows.h>
#include <stdio.h>

WCHAR* charToWide(const char *in)
{
	int len = strlen(in) + 1;

   WCHAR *wideString = malloc(len * sizeof(WCHAR));

   MultiByteToWideChar(CP_ACP, 0, in, len, wideString, len);

   return wideString;
}

#define MAXINLEN 200

int main()
{
    char eingabe[MAXINLEN];
    WCHAR *wideVersion;

    printf("Gib einen String ein\n");

    fgets(eingabe, MAXINLEN, stdin);

    printf("char - %s", eingabe);

    wideVersion = charToWide(eingabe);

    wprintf(L"WCHAR - %s", wideVersion);

    free(wideVersion);
}

der_Ronny

Danke Belli,

nun bin ich ebenfalls mehr oder weniger durch probieren zum gewünschten Erfolg gekommen - die WCHAR-Zeichenkette wird anscheinend korrekt ausgegeben....

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include "reghide.h"

WCHAR KeyNameBuffer[] = L"";  
char Teilschluessel[] = { "\\Registry\\Machine\\SOFTWARE\\Wow6432Node\\Classes\\CLSID\\" };
char Gesamtschluessel[] = { "" }; 

int main ()
{
char Schluesselname[40];

printf("Bitte geben Sie den Registryschluessel ein: \n");
gets(Schluesselname); 
printf("\n\n---------------------------------------------------\n");
printf("Schluesselname:                  %s\n",Schluesselname);
printf("Teilregistrierungsschluessel:    %s\n",Teilschluessel);
strcpy (Gesamtschluessel, Teilschluessel); 
strcat (Gesamtschluessel, Schluesselname);  
printf("Gesamtregistrierungsschluessel:  %s\n",Gesamtschluessel);

WCHAR *KeyNameBuffer = malloc((strlen(Gesamtschluessel) + 1) * sizeof(WCHAR)); 
MultiByteToWideChar(CP_ACP, 0, Gesamtschluessel, strlen(Gesamtschluessel) + 1, KeyNameBuffer, strlen(Gesamtschluessel) + 1);

wprintf(L"\n\nWCHAR:  %s\n",KeyNameBuffer);

printf("--------------------------------------------------- \n");

wprintf(L"\n\nWCHAR:  %s\n",KeyNameBuffer);

system("PAUSE");
return 0;
}

Danke auf jeden Fall vielmals für eure Mühen!