Różnica między znakiem * a znakiem const*?

char *name

Możesz zmienić znak, na który wskazuje name, a także znak, na który wskazuje.

const char* name

można zmienić znak, na który wskazuje name, ale nie można modyfikować znaku, na który wskazuje.
korekta: można zmienić wskaźnik, ale Nie znak, na który name wskazuje na ( https://msdn.microsoft.com/en-us/library/vstudio/whkd4k6a (v=vs.100). aspx , patrz "przykłady"). W tym przypadku const specifier dotyczy char, a nie gwiazdki.

Według strony MSDN i http://en.cppreference.com/w/cpp/language/declarations , const przed * jest częścią sekwencji dekl-specifier, podczas gdy const po * jest częścią Decl-specifier.
Po sekwencji deklaracji może następować wiele deklaratorów, dlatego const char * c1, c2 deklaruje c1 jako const char * i c2 jako const char.

EDIT:

Z komentarzy, Twój question wydaje się być pytaniem o różnicę między dwoma deklaracjami, gdy wskaźnik wskazuje na literalny łańcuch znaków.

W takim przypadku, nie powinieneś modyfikować znaku, na który wskazuje name, ponieważ może to spowodować niezdefiniowane zachowanie . Literały łańcuchów mogą być przydzielane w regionach pamięci tylko do odczytu (zdefiniowanych w implementacji) i program użytkownika nie powinien ich modyfikować. Każda próba tego powoduje nieokreślone zachowanie.

Więc jedynym różnica w tym przypadku (użycie z literałami ciągów) polega na tym, że druga deklaracja daje niewielką przewagę. Kompilatory zazwyczaj dają ostrzeżenie w przypadku próby zmodyfikowania ciągu literalnego w drugim przypadku.

Przykładowy Online:

#include <string.h>
int main()
{
    char *str1 = "string Literal";
    const char *str2 = "string Literal";
    char source[] = "Sample string";

    strcpy(str1,source);    //No warning or error, just Undefined Behavior
    strcpy(str2,source);    //Compiler issues a warning

    return 0;
}

Wyjście:

Cc1: Ostrzeżenia traktowane jako błędy
prog.c: w funkcji "main":
prog.c: 9: error: passing argument 1 of' strcpy ' disclards qualifiers from pointer target type

Zauważ, że kompilator ostrzega o drugim przypadku, ale nie o pierwszym.

char mystring[101] = "My sample string";
const char * constcharp = mystring; // (1)
char const * charconstp = mystring; // (2) the same as (1)
char * const charpconst = mystring; // (3)

constcharp++; // ok
charconstp++; // ok
charpconst++; // compile error

constcharp[3] = '\0'; // compile error
charconstp[3] = '\0'; // compile error
charpconst[3] = '\0'; // ok

// String literals
char * lcharp = "My string literal";
const char * lconstcharp = "My string literal";

lcharp[0] = 'X';      // Segmentation fault (crash) during run-time
lconstcharp[0] = 'X'; // compile error

// *not* a string literal
const char astr[101] = "My mutable string";
astr[0] = 'X';          // compile error
((char*)astr)[0] = 'X'; // ok

W żadnym przypadku nie można modyfikować literału łańcuchowego, niezależnie od tego, czy wskaźnik do niego jest zadeklarowany jako char * lub const char *.

Jednak różnica polega na tym, że jeśli wskaźnik jest const char *, kompilator musi dać diagnostykę, jeśli próbujesz zmodyfikować wartość wskazywaną, ale jeśli wskaźnik jest char *, to nie.

Pierwszy można rzeczywiście zmienić, jeśli chcesz, drugi nie. poczytaj o const poprawności (jest kilka fajnych poradników o różnicy). Istnieje również char const * name gdzie nie można go ponownie umieścić.

W rzeczywistości char* name nie jest wskaźnikiem do stałej, ale wskaźnikiem do zmiennej. Możesz mówić o tym innym pytaniu.

Jaka jest różnica między char * const a const char*?

Przypadek 1:

char *str = "Hello";
str[0] = 'M'  //No warning or error, just Undefined Behavior

Powyższe ustawienie str wskazuje na literalną wartość "Hello", która jest zakodowana na twardo w obrazie binarnym programu, który jest oznaczany jako Tylko do odczytu w pamięci, oznacza, że każda zmiana w tym Literale jest nielegalna i powodowałaby błędy segmentacji.

Przypadek 2:

const char *str = "Hello";
str[0] = 'M'  //Compiler issues a warning

Przypadek 3:

char str[] = "Hello";
str[0] = 'M'; // legal and change the str = "Mello".

Dla dodatkowego przykładu:

    std::cout << typeid(2.3).name() << '\n'; // -----> prints "double" simply because
    //2.3 is a double
    //But the "double" returned by typeid(2.3).name() is indeed a 
    //const char * which consists of 'd','o','u','b','l','e'and'\0'.
    //Here's a simple proof to this:
    std::cout << typeid(typeid(2.3).name()).name() << '\n'; //prints: "const char *"
    const char* charptr
    charptr = typeid(2.3).name();
    std::cout << charptr[3]; // --------->  prints: "b"

(używam biblioteki typeinfo: http://www.cplusplus.com/reference/typeinfo/type_info/name )

    //Now let's do something more interesting:
    char* charptr2="hubble";
    strcpy(charptr, charptr2);  // --------> Oops! Sorry, this is not valid!

Pytanie, Jaka jest różnica między

char *name

Który wskazuje na stały ciąg literalny i

const char *cname

Tzn. podane

char *name = "foo";

I

const char *cname = "foo";

Nie ma dużej różnicy między 2 i oba mogą być postrzegane jako prawidłowe. Ze względu na długą spuściznę kodu C, literały łańcuchów mają typ char[], a nie const char[], i istnieje wiele starszych kodów, które podobnie akceptują char * zamiast const char *, nawet jeśli nie modyfikują argumentów.

Zasadnicza różnica 2 w ogóle polega na tym, że *cname lub cname[n] będą oceniać do wartości LV typu const char, podczas gdy *name lub name[n] będą oceniać do wartości LV typu char, które są , które można modyfikować do wartości LV. Kompilator zgodny jest wymagany do wygenerowania komunikatu diagnostycznego, jeśli cel przypisania nie jest modyfikowanym lvalue; nie musi generować żadnego ostrzeżenia przy przypisaniu do lvalue typu char:

name[0] = 'x'; // no diagnostics *needed*
cname[0] = 'x'; // a conforming compiler *must* produce a diagnostics message

Kompilator nie jest wymagane aby zatrzymać kompilację w obu przypadkach; wystarczy, że wygeneruje Ostrzeżenie dla przypisania do cname[0]. Wynikowy program nie jest poprawnym programem. Zachowanie konstrukcji jest niezdefiniowane . Może się zawiesić, lub co gorsza, może się nie zawiesić i może zmienić literalny ciąg znaków w pamięci.