Skip to content
#C++

表达式

约 1381 个字 25 行代码 1 张图片 预计阅读时间 7 分钟

左值和右值

  • C++表达式要么为左值要么为右值
  • 赋值运算符需要一个左值作为左侧运算对象，得到的结果仍然是一个左值
  • 取地址符：得到的指针是一个右值
  • 内置解引用符和下标运算符，迭代器解引用符，string & vector的下标运算符均是左值
  • 内置类型和迭代器的递增递减运算符作用于左值运算对象

递增和递减运算符

  • 作用于左值运算对象，前置版本将对象本身作为左值返回；后置版本作为右值返回
  • 不建议使用后置版本

类型转换

算数转换

  • 整型提升：把小整数类型转换成较大的整数类型

其他隐式类型转换

  • 数组转换成指针

  • 指针的转换转换成bool

  • 转换成常量

  • 类类型定义的转换

C++
string s,t = "a value";   // 字符串字面值转化为string类型
while(cin >> s)           // while把cin转化为Bool

类型转换符

  • const_cast
  • const_cast只针对指针、引用，当然，this指针也是其中之一
  • const_cast的大部分使用主要是将常量指针转换为常指针。常量指针指向的空间的内容不允许被修改，但是使用const_cast进行强制转换就可以修改。

  • const_cast只能调节类型限定符，不能修改基本类型。

  • static_cast

  • static_cast的使用基本等价于隐式转换的一种类型转化运算符，可使用于需要明确隐式转换的地方。就相当于把隐式转换给明确写了出来而已

  • 可用于低风险转换，高风险转换不行

  • dynamic_cast

  • 用于具有虚函数的基类与派生类之间的指针或引用的转换。
  • 基类必须具有虚函数。dynamic_cast是运行时类型信息（RTTI），而这个信息是存储与类的虚函数表关系紧密的信息，只有一个类定义了虚函数，才会有虚函数表。运行时检查，转型不成功则返回一个空指针,非必要不使用dynamic_cast，因为有额外的开销。
  • 常用的转换方式
    基类指针或引用转派生类指针（必须使用dynamic_cast）
    派生类指针或引用转基类指针（可以使用dynamic_cast,但是更推荐用static_cast）
C++
B *pb; // B is base class
D *pd, md; // D is 派生 class
pb=&md; 
pd=dynamic<D*>(pb);

  • reinterpret_cast

  • 强制转换

C++
const std::string& StrVector::at(size_t index) const {
 return static_cast<const
std::string&>(const_cast<StrVector*>(this)->at(index));

RTTI

  • Run Time Type Identification：运行时类型识别；程序使用基类的指针或引用检查这些指针或引用所指对象的实际派生类型

typeid运算符

  • typeid运算符，后接一个类型名或一个表达式，该运算符返回一个类型为std::tpeinfo的对象的const引用。type_info是std中的一个类，它用于记录与类型相关的信息。

  • typeid识别静态类型

当typeid中的操作数是如下情况之一时，typeid运算符指出操作数的静态类型，即编译时的类型。

（1）类型名

（2）一个基本类型的变量

（3）一个具体的对象

（4）一个指向不含有virtual函数的类对象的指针的解引用

（5）一个指向不含有virtual函数的类对象的引用

静态类型在程序的运行过程中并不会改变，所以并不需要在程序运行时计算类型，在编译时就能根据操作数的静态类型，推导出其类型信息。

  • typeid识别多态类型

当typeid中的操作数是如下情况之一时，typeid运算符需要在程序运行时计算类型，因为其其操作数的类型在编译时期是不能被确定的。

（1）一个指向不含有virtual函数的类对象的指针的解引用

（2）一个指向不含有virtual函数的类对象的引用

多态的类型是可以在运行过程中被改变的，例如，一个基类的指针，在程序运行的过程中，它可以指向一个基类对象，也可以指向该基类的派生类的对象，而typeid运算符需要在运行过程中识别出该基类指针所指向的对象的实际类型，这就需要typeid运算符在运行过程中计算其指向的对象的实际类型。

  • 关于多态类型的计算是通过基类指针或引用指向的对象（子对象）的虚函数表获得的

  • 然而在C++中即使一个类不具有多态的性质，仍然允许把一个派生类的指针赋值给一个基类的指针，所以这个错误比较隐晦。

前向声明

  • A forward declaration allows us to tell the compiler about the existence of an identifier before actually defining the identifier.
C++
#include <iostream>

int add(int x, int y); // forward declaration of add() (using a function declaration)

int main()
{
    std::cout << "The sum of 3 and 4 is: " << add(3, 4) << '\n'; // this works because we forward declared add() above
    return 0;
}

int add(int x, int y) // even though the body of add() isn't defined until here
{
    return x + y;
}

Declarations vs. definitions

  • A declaration is a statement that tells the compiler about the existence of an identifier and its associated type information. Here are some examples of declarations:
C++
int add(int x, int y); // tells the compiler about a function named "add" that takes two int parameters and returns an int.  No body!
int x;                 // tells the compiler about an integer variable named x
  • In C++, all definitions also serve as declarations

The one definition rule(ODR)

  • The one definition rule (or ODR for short) is a well-known rule in C++. The ODR has three parts:

  • Within a given file, a function, variable, type, or template can only have one definition.

  • Within a given program, a variable or normal function can only have one definition. This distinction is made because programs can have more than one file (we’ll cover this in the next lesson).

  • Types, templates, inline functions, and inline variables are allowed to have identical definitions in different files. We haven’t covered what most of these things are yet, so don’t worry about this for now -- we’ll bring it back up when it’s relevant.