Question

为什么我不能这样做：

char* p = new char[10];

void SetString(char * const str)
{
    p = str;
}


SetString("Hello");

我有一个指向char的const指针，为什么我不能将const指针指向另一个指针？

这看起来似乎不合逻辑，因为通过将其分配给另一个指针，您基本上不会违反char指针的常量。或者是你？

编辑：当我编译它时，它说“错误C2440：'='：无法从'char * const * __ w64'转换为'char *'”

（我试图从我正在阅读的书中理解一个概念。只是无法获得编译的代码。

CODE：

int _tmain(int argc, _TCHAR* argv[])
{

    MyString *strg = new MyString(10);
    strg->SetString("Hello, ");

    MyString *secondstr = new MyString(7);
    secondstr->SetString("Tony");

    strg->concat(*secondstr, *strg);

}

CPP文件：

#include "MyStringClass.h"
#include <string.h>
#include "stdafx.h"

#include "MyStringClass.h"

void MyString::concat(MyString& a, MyString& b)
{
    len = a.len + b.len;
    s = new char[len + 1];
    strcpy(s, a.s);
    strcat(s, b.s);
    delete [] s; 

}

void MyString::SetString(char * const str)
{
    s = str;
}

MyString::MyString(int n)
{
    s = new char[n+1];
    s[n+1] = '\0';
    len = n;
}

HEADER FILE：

#include <string.h>
#include <stdio.h>

class MyString
{
private:
    char* s;
    int len;
public:
    MyString(int n = 80);

    void SetString (char * const str);

    void concat (MyString& a, MyString& b);
};

Answer 1

常量指针和指向常量的指针之间存在差异。常量指针是一个无法更改的指针（数字 - 内存地址） - 它始终指向通过初始化给出的同一对象：

int * const const_pointer = &some_int_var; // will be always pointing to this var
const_pointer = &some_other_var; // illegal - cannot change the pointer
*const_pointer = 2; // legal, the pointer is a pointer to non-const

指向常量的指针是一个指针，其指向值无法更改：

const int * pointer_to_const = &some_int_var; // doesn't have to be always pointing to this var
pointer = &some_other_var; // legal, it's not a constant pointer and we can change it
*pointer = 2; // illegal, pointed value cannot be changed

您始终可以将常量赋值给变量，即const指针指向非常量指针（a）。您可以将指向非const的指针转换为指向const（b）的指针。但是你不能将const指针转换为指向非const（c）的指针：

int * pointer;
int * const const_pointer = &var;
const int * pointer_to_const;

/* a */
pointer = const_pointer; // OK, no cast (same type)

/* b */
pointer_to_const = pointer; // OK, casting 'int*' to 'const int*'

/* c */
pointer = pointer_to_const; // Illegal, casting 'const int*' to 'int*'

[编辑]下面，这不是标准的c ++。但是，这很常见。[/ EDIT]
字符串文字

"Hello"

转换为指向const（const char * const）的常量指针：

char *pointer = "Hello"; // Illegal, cannot cast 'const char*' to 'char*'
char * const const_pointer = "Hello"; // Illegal, cannot cast 'const char*' to 'char*'
const char * pointer_to_const = "Hello"; // OK, we can assign a constant to a variable of the same type (and the type is 'const char*')
"Hello" = pointer_to_const; // Illegal cannot re-assign a constant

在上面的例子中，第二个是你的情况。在将字符串文字作为函数的参数传递时，您尝试使用指向const 的指针初始化指向非常量。无论这些指针是否是常量，它们指向的是什么。

要点：
1）如果将某种类型的指针强制转换为另一种类型的指针，则不能将指针指向const转换为指向非const的指针。
2）如果你有常量指针，相同的规则适用于其他常量 - 你可以为变量赋值，但不能将变量赋值给常量（初始化除外）。

//编辑
正如GMan指出的那样，C ++ 98标准（§4.2/ 2）允许隐式地将字符串文字（它是常量字符数组）转换为非const字符指针。这是因为向后兼容（在C语言中没有常量）。

当然，这样的转换可能会导致错误，编译器会违反规则并显示错误。但是，兼容模式下的GCC仅显示警告。

const指针指向一个指针

1 个答案: