从int **到const int **的转换 [英] Conversion from int** to const int**

问题描述

为什么要输入此代码:

void foo ( const int ** );

int main() {
    int ** v = new int * [10];
    foo(v);

    return 0;
}

此错误:

invalid conversion from ‘int**’ to ‘const int**’ [-fpermissive]|

我认为可以从非const转换为const.

I thought it would be possible to convert from non-const to const.

推荐答案

这是因为您正在尝试从int** to const int**

it is because you are trying to convert from int** to const int**

int ** v = new int * [10]; // v is int**
foo(v); //but foo takes const int**

• int **是:指向整数的指针".
• const int **是:指向常量整数的指针".
• int ** is: "a pointer to a pointer to an integer".
• const int ** is: "a pointer to a pointer to a constant integer".

使用const是合同，您不能通过两个引用的间接访问来满足此合同.

The use of const is a contract and you cannot meet this contract by going through the indirection of two references.

根据标准:

const char c = 'c';
char* pc;
const char** pcc = &pc;   // not allowed (thankfully!)
                ^^^ here the bundit is hidden under const: "I will not modify"
*pcc = &c;                // *pcc is "pointer to const" right? so this is allowed...
*pc = 'C';                // would allow to modify a const object, *pc is char right?

，因此可以始终修改const char ，只需使用上面的过程即可.

so it would be possible to modify const char always, just use procedure above.

还有:

char *s1 = 0;
const char *s2 = s1; // OK...
char *a[MAX]; // aka char **
const char * const*ps = a; // no error!

很好地从下面的链接中引用:

nice cite from the link below:

以类推的方式，如果您将罪犯隐藏在合法的伪装之下，他 然后可以利用对这种伪装的信任.不好.

By way of analogy, if you hide a criminal under a lawful disguise, he can then exploit the trust given to that disguise. That's bad.

http://www.parashift.com/c++-faq- lite/constptrptr-conversion.html

也是无效的转换Derived** → Base**.如果转换Derived** → Base**是合法的，则可以取消引用Base**(产生Base*)，并且可以使Base *指向不同派生类的对象，这可能会导致严重的问题.看看原因:

related to this is also invalid conversion Derived** → Base**. If it were legal to convert Derived** → Base**, the Base** could be dereferenced (yielding a Base*), and the Base* could be made to point to an object of a different derived class, which could cause serious problems. See why:

class Vehicle {
public:
  virtual ~Vehicle() { }
  virtual void startEngine() = 0;
};

class Car : public Vehicle {
public:
  virtual void startEngine();
  virtual void openGasCap();
};

class NuclearSubmarine : public Vehicle {
public:
  virtual void startEngine();
  virtual void fireNuclearMissle();
};

int main()
{
  Car   car;
  Car*  carPtr = &car;
  Car** carPtrPtr = &carPtr;
  Vehicle** vehiclePtrPtr = carPtrPtr;  // This is an error in C++
  NuclearSubmarine  sub;
  NuclearSubmarine* subPtr = ⊂
  *vehiclePtrPtr = subPtr;
  // This last line would have caused carPtr to point to sub !
  carPtr->openGasCap();  // This might call fireNuclearMissle()!
  ...
}

http://www.parashift.com/c++- faq-lite/derivedptrptr-to-baseptrptr.html

考虑:

class Vehicle {
public:
  virtual ~Vehicle() { }
  virtual void startEngine() = 0;
};
class Car : public Vehicle {
public:
  virtual void startEngine(){printf("Car engine brummm\n");}
  virtual void openGasCap(){printf("Car: open gas cap\n");}
    virtual void openGasCap2(){printf("Car: open gas cap2\n");}
      virtual void openGasCap3(){printf("Car: open gas cap3\n");}
            virtual void openGasCap4(){printf("Car: open gas cap4\n");}
}; 
class NuclearSubmarine : public Vehicle {
public:
    int i;
  virtual void startEngine(){printf("Nuclear submarine engine brummm\n");}
    virtual void fireNuclearMissle3(){printf("Nuclear submarine: fire the missle3!\n");}
    virtual void fireNuclearMissle(){printf("Nuclear submarine: fire the missle!\n");}
  virtual void fireNuclearMissle2(){printf("Nuclear submarine: fire the missle2!\n");}
};   
int main(){
  Car   car; Car*  carPtr = &car;
  Car** carPtrPtr = &carPtr;
  //Vehicle** vehiclePtrPtr = carPtrPtr;  // This is an error in C++, But:
  Vehicle** vehiclePtrPtr = reinterpret_cast<Vehicle**>(carPtrPtr);
  NuclearSubmarine  sub; NuclearSubmarine* subPtr = &sub;
  *vehiclePtrPtr = subPtr; // carPtr points to sub !
  carPtr->openGasCap();  // Nuclear submarine: fire the missle3!
  carPtr->openGasCap2();  // Nuclear submarine: fire the missle!
  carPtr->openGasCap3();  // Nuclear submarine: fire the missle2!
  //carPtr->openGasCap4();  // SEG FAULT 
}

这篇关于从int **到const int **的转换的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！