标签: const

我正在尝试使用"Effective C++,Third edition"一书来学习一些C++编码的最佳实践.

在第3项中,作者谈到了const成员职能.它们给出了一个示例类,它们将[]操作符重载两次 - 一次用于非const,一次用于const对象.给出以下代码:

class TextBlock {
public:
 ...
 const char&                                       // operator[] for
 operator[](const std::size_t position) const      // const objects
 { return text[position]; }
 char&                                             // operator[] for
 operator[](const std::size_t position) const      // non-const objects
 { return text[position]; }
private:
   std::string text;
};

TextBlock tb("Hello");
std::cout << tb[0];                   // calls non-const
                                      // TextBlock::operator[]
const TextBlock ctb("World");
std::cout << ctb[0];                  // calls const TextBlock::operator[]

所以我试图实现这个片段只是为了得到一些练习.

#include <iostream>
#include <string>

class text_block
{
    public:
        text_block(const …

我有一个矢量::

static const std::vector<float> vector1

和一个向量的引用:

std::vector<float> const& vector2

我需要将这些矢量的值相互相乘,并将它们存储在一个新的矢量中.

例如:

result[0]=vector1[0]*vector2[0]
result[1]=vector1[1]*vector2[1]

然后我需要将这个向量赋给一个只接受的方法:

std::vector<float> const& result

我如何在C++中执行此操作？

根据我对使用const类型限定符和指针的理解,它取决于你使用它的位置.

const MyType *

意味着该位置无法修改,但该位置的值可以.

MyType const *

意味着可以修改位置,但不能修改位置的值.

由此,我认为没有理由不能使以下内容无效,

const MyType const *

定义一个位置固定的指针,并且无法修改指向的值.但是,这就是"不止一次使用相同类型的限定符".我应该忽略这个吗？我对指针上下文中const语义的理解是否有缺陷？

好吧,所以这是我测试时的一项任务.您需要使用const int userID创建一个类User,以便每个User对象都具有唯一的ID.

我被要求用2个参数重载构造函数:key,name.如果密钥为0,则用户将具有唯一ID,否则用户将获得userID = -1.

我这样做了:

class User{
private:
    static int nbUsers;
    const int userID;
    char* name;
public:
    User(int key, char* name) :userID(nbUsers++){
        if (name != NULL){
            this->name = new char[strlen(name) + 1];
            strcpy(this->name);
        }
    }

};

我不知道如何首先检查key参数是否为0然后初始化const userID.有什么想法吗？

对于一个项目,我正在尝试使用矢量函数创建一个矢量类.我试图通过覆盖+ =加法赋值来添加向量加法函数.因为我不希望+ =函数更改要添加的值我想将该值传递为const reference.

我的代码:

Vector2D.h

#pragma once
class Vector2D
{
private:
    int m_x, m_y;
public:

    Vector2D(int x, int y);
    int getX();
    int getY();
    void setX(int x);
    void setY(int y);
    Vector2D& operator+=(const Vector2D&);
};

Vector2D.cpp

#include "Vector2D.h"
Vector2D::Vector2D(int x, int y)
{
    m_x = x;
    m_y = y;
}

int Vector2D::getX()
{
    return m_x;
}

int Vector2D::getY()
{
    return m_y;
}

void Vector2D::setX(int x)
{
    m_x = x;
}

void Vector2D::setY(int y)
{
    m_y = y;
}

Vector2D& …

为什么这不合法？

class Base {
public:
    virtual void bar() = 0;
    virtual void barc() const = 0;
};

class Derived: public Base {
public:
    // deliberately omitted
    // virtual void bar()
    virtual void barc() const override { };
};

int main() {
    const Derived b;
    b.barc();
    // b.bar();
    // fails as expected with "passing 'const Bar' as 'this' argument discards qualifiers"
}

这失败并出现以下错误,因为我没有定义virtual void bar():

prog.cpp: In function 'int main()':
prog.cpp:16:12: error: cannot declare variable 'd' to be of …

我在这里关注meteorjs的教程:https://www.meteor.com/tutorials/react/forms-and-events

其中一个代码是使用const. const text = ReactDOM.findDOMNode(this.refs.textInput).value.trim();

据我在SO网站其他网站上的阅读所知,const价值无法改变.但是,当我键入我的应用程序输入框中的任何文本时,没有抛出重新分配const值的错误.

为什么会这样,我明白const错了？我希望有人可以向我解释并提前感谢.

示例代码:

import React, { Component, PropTypes } from 'react';
import ReactDOM from 'react-dom';
import { createContainer } from 'meteor/react-meteor-data';

import { Tasks } from '../api/tasks.js';
...some lines skipped...

// App component - represents the whole app
class App extends Component {
  handleSubmit(event) {
    event.preventDefault();

    // Find the text field via the React ref
    const text = ReactDOM.findDOMNode(this.refs.textInput).value.trim();

    Tasks.insert({
      text,
      createdAt: new Date(), // current …

这个答案在这个问题介绍了如何通过非关联化的指针,它的地址作品(显然是通过创建一个新的变量)改变一个常数变量.

const int i = 10;
*(int *)&i = 5;

std::cout << &i << "\t" << i << "\n";                   // 0x7fff6b325244   10

std::cout << &*(int *)&i << "\t" << *(int *)&i << "\n"; // 0x7fff6b325244   5

随着&*(int *)&i我试图让以前的答案是谈论新的变量的地址.如何找到存储此新变量的位置？

*(int *)&i 显示不同的值,因此必须有一个新变量.

在g ++ 5.4.0,Ubuntu 16.04上编译

从我在网上和SO上看到的内容:

常量:

• 告诉编译器不能使用程序指令更改变量.
• 因此,编译器可以优化代码.

挥发性:

• 变量是常量但可以从程序外部更改.
• 告诉编译器每次都从内存中读取变量的值.
• 告诉编译器不要对这个变量使用优化.

如果我的理解是正确的,那么易变性只是另一种常量.

那么,像下面那样的线是什么意思呢？

const volatile char A = 'C';

我搜索了互联网和StackOverflow关于const_cast <>及其引起的混乱,我找到了有用的东西,但是我还有一个问题.

考虑到这段代码,

#include <iostream>
using namespace std;

int main(void)
{
    const int a = 1;
    int *p = const_cast<int*>(&a);
    *p = 2;

    cout << "value a="<< a << endl;
    cout << "value *p=" <<*p << endl;
    cout << "address a=" <<&a << endl;
    cout << "address p=" <<p << endl;
}

输出是:

值a = 1
值*p = 2
地址a = 0x69fef8
地址p = 0x69fef8

我发现这样的代码可能导致未定义的行为.(例如,编译器可能会将所有a's 替换为's以1进行优化,因此强制转换没有意义)

我也发现了这句话:

如果抛弃已显式声明为const的对象的常量,并尝试修改它,则结果是未定义的.

但是,如果丢弃未明确声明为const的对象的常量,则可以安全地修改它.

还有这个:

请注意,C++提供const_cast了删除或添加常量的变量.但是,在删除constness时,它应该用于从引用/指针中删除constness,以指向原本不是常量的东西. …