Kapitel 2 C++: Variablen und Grundtypen

Einführung in die Grundkenntnisse der Sprache und der Standardbibliothek

Kapitel 2 Variablen und Grundtypen

Einige Sprachen, wie Smalltalk und Python, überprüfen den Datentyp, wenn die Programm läuft; Im Gegensatz dazu ist C++ eine statisch typisierte Sprache, bei der die Typprüfung zur Kompilierzeit erfolgt.
- Integrierter Typ: Ein durch die Sprache definierter Typ, z. B. int.
- Klassentyp: Vom Programmierer definierter Datentyp.

++ Datentypen sagen uns, was die Daten bedeuten und welche Operationen wir mit den Daten durchführen können. ++

Grundlegende integrierte Typen

Begriffsblock: Die grundlegendste Methode, die verwendet wird, um Speicher zu verwalten und dem Speicher eine Struktur zu geben. Die Anzahl der Bits in einem Block ist im Allgemeinen eine Potenz von 2, sodass 8, 16, 32, 64 oder 128 Bits gleichzeitig verarbeitet werden können. Achten Sie auf die Unterscheidung von Blöcken.

++Der kleinste adressierbare Speicherblock wird „Byte“ genannt; die Grundeinheit des Speichers heißt „Wort“, die normalerweise aus mehreren Bytes besteht. ++
- arithmetischer Typ : Ganzzahl, Gleitkommazahl, Einzelzeichen, boolescher Wert
- Integraltyp : Die arithmetischen Typen, die ganze Zahlen, Zeichen und boolesche Werte darstellen, werden zusammenfassend als Integraltypen
bezeichnet -Zeichentyp: char (einzelnes Maschinenbyte: Byte) und wchar_t (breiter Zeichentyp, der zum Erweitern von Zeichensätzen wie chinesischen und japanischen Zeichen verwendet wird)
- kurz: ein halbes Maschinenwort; int: ein Maschinenwort; lang: zwei Maschinenwörter. ps: Die Wortlängen von int und long sind auf 32-Bit-Maschinen normalerweise gleich. Der Mindestspeicherplatz beträgt 16 Bit, 16 Bit bzw. 32 Bit
- Zuweisung eines ganzzahligen Typs: Wenn Sie einen Wert zuweisen, nehmen Sie den Wert modulo zur Anzahl der Werte des Typs.
- Gleitkommatyp: einfache Präzision, doppelte Präzision, erweiterte Präzision (langes Doppel)
- Im Allgemeinen belegt Float 1 Wort (32 Bit), Double 2 Wörter (64 Bit) und Long Double wird durch 3 oder 4 Wörter (96 oder 128 Bit) dargestellt.
- Normalerweise wird Double gewählt, Float weist einen großen Genauigkeitsverlust auf (Double kann mindestens 10 signifikante Ziffern garantieren, Float kann nur 6 Ziffern garantieren) und der Berechnungsaufwand für Double ist im Vergleich zu Float vernachlässigbar.
- Die maximale Anzahl von 16-Bit-Signaturen beträgt 32767 und die maximale Anzahl von vorzeichenlosen 65535.
- Leerer Typ (void) : Wird normalerweise als Rückgabetyp von Funktionen ohne Rückgabewerte verwendet

Typkonvertierung

unsigned char c = -1;     //假设char占8比特，c的值为255signed char c2 = 256;     //假设char占8比特，c2的值是未定义的

• Wenn wir einem vorzeichenlosen Typ einen Wert zuweisen, der außerhalb des von ihm dargestellten Bereichs liegt, ist das Ergebnis der Rest des Anfangswerts modulo der Gesamtzahl der vom vorzeichenlosen Typ dargestellten Werte.

• Wenn wir einem vorzeichenbehafteten Typ einen Wert zuweisen, der außerhalb des von ihm dargestellten Bereichs liegt, ist das Ergebnis undefiniert (undefiniert). Zu diesem Zeitpunkt funktioniert das Programm möglicherweise weiter, stürzt ab oder generiert fehlerhafte Daten.

• Sie können signierte und nicht signierte Typen nicht mischen. Wenn beide Typen im Ausdruck vorhanden sind, werden vorzeichenbehaftete Zahlen automatisch in vorzeichenlose Zahlen umgewandelt.

Literale Konstante

• Sie wird als Literalwert bezeichnet, weil sie nur durch ihren Wert aufgerufen werden kann. Eine Konstante ist, weil ihr Wert nicht sein kann geändert.

• Nur ​​integrierte Typen haben Literalwerte, es gibt keine Literalwerte für Klassentypen und daher gibt es keine Literalwerte für Standardbibliothekstypen.

• Verwenden Sie dezimal, oktal (beginnend mit 0) oder hexadezimal (beginnend mit 0x oder 0X)

//20的三种表示：20      /*十进制*/024     /*八进制*/0x14    /*十六进制*/

1. Integer-Literal: Der Literal-Konstantentyp ist standardmäßig int oder long. Durch Hinzufügen eines Suffixes kann die Konvertierung des Literalwerts in „long“, „unsinged“ oder „unsigned long“ erzwungen werden. Das Suffix ist L, U, UL oder LU (Kleinbuchstaben sind ebenfalls akzeptabel. Die Verwendung von l wird nicht empfohlen. und es kann leicht mit 1) verwechselt werden.

2. Gleitkomma-Literal : ausgedrückt in dezimaler oder wissenschaftlicher Notation (mit e oder E). Der standardmäßige Doppeltyp ist: Fügen Sie F oder f hinzu, um die einfache Genauigkeit anzugeben, und fügen Sie L oder l hinzu, um die erweiterte Genauigkeit anzugeben.

3. Boolesches Literal : wahr und falsch.

4. Zeichenliteralwert:

   名称	书写
   换行符	n
   水平制表符	t
   纵向制表符	v
   退格符	b
   回车符	r
   疑问号	?
   双引号	”

• \ooo：这里的ooo表示三个八进制数字，这三个数字表示字符的数字值。如’\0’通常表示“空字符（null character）”。

• 也可以用十六进制转义字符来定义：\xddd。一个反斜线、一个x和一个或多个十六进制数组成。

• 通用转义字符：
  

• 可打印字符通常用一对单引号定义，如‘a’；在前面加L就能得到wchar_t类型的宽字符字面值，如L‘a’。

• 不可打印字符和特殊字符都用转义字符书写，转义字符以反斜线开始。

字符串字面值：

• 双引号括起来的0个或多个字符。

• 为了兼容C语言，C++所有的字符串字面值都由编译器自动在末尾添加一个空字符(‘\0’)，因此，其实际长度要比它的内容多1。

• 宽字符字面值：在字符串前面加L，如L“asdff”。

• 多行字面值：两个字符串字面值位置紧邻且仅由空格、缩进和换行符分割，则它们实际上是一个整体。

• 不依赖未定义行为和机器相关行为，否则这样的程序时不可移植的（nonportable）。

指针字面值：nullptr

变量

变量提供了程序可操作的有名字的存储区
- 左值和右值
  - 左值(lvalue)：变量的地址，或者是一个代表“ 对象在内存中的位置”的表达式。
  - 右值(rvalue)：变量的值

变量名出现在赋值运算符的左边，就是一个左值；而出现在赋值运算符右边的变量名或字面常量就是一个右值。

    如：
    val1=val2/8
    这里的val1是个左值，而val2和8都是右值。

- 对象：内存中具有类型的区域
- 变量名：即变量的标识符（identifier）。
   1. 由字母、数字和下划线组成.
   2. 变量名必须以字母或下划线开头，并且区分大小写。（函数体外的变量名不能以下划线开头）
   3. C++关键字不能用做标识符
   4. 不能包含两个连续的下划线
   5. 不能以下划线开头后紧跟一个大写字母

• 定义对象（如：int a；）

  每个定义都是以类型说明符(type specifier)开始的（如：int）

  int ival(1024);//direct-initialization,直接初始化int ival = 1024;//copy-initialization,复制初始化//注：直接初始化语法更灵活，且效率更高。

• 列表初始化（list initialization）(C++11新特性)

  int ival{1024};int ival = {1024}；long double ld = 3.1415926536;int a{ld}, b = {ld};    //错误：转换未执行，因为存在丢失信息的风险int c(ld), d = ld;      //正确：转换执行，且丢失部分值

• 初始化&赋值：初始化不是赋值。

• 默认初始化（default initialized）：如果内置类型的变量未被显示初始化，它的值由定义的位置决定。定义于任何函数体之外的变量被初始化为0，内部的将不被初始化。

• 建议初始化每个内置型变量，以保证程序安全。

• 初始化

• 变量的声明

  extern int i;   //声明i而非定义iint j;          //定义j

• 变量只能被定义一次，但能被多次声明。

• 如果要在多个文件中使用同一个变量，就必须将声明和定义分离。变量的定义必须出现且只能处在在一个文件中，而其他用到该变量的文件必须对其进行声明，却决不能重复定义。

• 如果想声明一个变量而非定义它，在变量名前加关键字extern，且不要显示地初始化变量：

• 变量名的作用域（scope）：以花括号分隔

  全局作用域（global scope）

  块作用域（block scope）

复合类型（compound type）

• 引用（reference），此处指左值引用（lvalue reference）。

  int ival = 1024;int &refVal = ival; //refVal指向ival（是ival的另一个名字）int &refVal；       //报错，引用必须被初始化

• 引用不是对象，只是已经存在的对象的另一个名字。程序将引用和他的初始值绑定（bind）在一起，而不是直接将初始值拷贝给引用。

• 指针（pointer）

  int i = 42;     
  int &r = i;     //&紧随类名出现，因此是声明的一部分，r是一个引用int *p;         //*紧随类名出现，因此是声明的一部分，p是一个指针p = &i;         //&出现在表达式中，是一个取地址符*p = i;         //*出现在表达式中，是一个解引用符int &r2 = *p;

• 指针是对象，允许赋值和拷贝，且在指针的生命周期内它可以先后指向不同的几个对象。

• 指针无需在定义时赋值。

• 指针类型和它所指向的对象的类型必须匹配。

  int *ip1, *ip2;int val = 4;int *p = &val;

• 如果指针指向了一个对象，则允许用解引用符（操作符*）来访问该对象：

  int ival - 42;int *p = &ival;cout << *p;     //由符号*得到指针p所指的对象，输出42*p = 0;         //由符号*得到指针p所指的对象，即可经由p为变量ival赋值cout << *p;     //输出0

• 符号的含义由上下文决定

• 空指针

int *p1 = nullptr;int *p2 = 0;int *p3 = NULL;     //需要首先#include cstdlib

• 建议初始化所有指针

• 面对一条比较复杂的指针或引用的声明语句时，从右向左阅读有助于弄清它的真实含义。

const限定符

定义常量。
- 指针和const
   - 顶层const（top-level const）：表示指针本身是个常量
   - 底层const（low-level condt）：表示指针所指的对象是个常量

• 指向常量的指针（pointer to const）

  const double pi = 3.14;double *ptr = π          //错误！const double *cptr = π   //正确*cptr = 42;                 //错误！cptr指向常量，不能向常量赋值double dval = 3.14;
  cptr = &dval;               //正确，但不能通过cptr改变dval的值，因为cptr以为自己指向的是常量

• 常量指针（const pointer）

  int errNum = 0;int *const curErr = &errBum;    //curErr将一直指向errNumconst double pi = 3.14;const double *const pip = π  //pip是一个指向常量对象的常量指针

• constexpr和常量表达式

• C++11新标准：将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。（用const，有些常量的具体值直到运行时才能获取）

• 在constexpr声明中如果定义了一个指针，限定符仅对指针有效，与指针所知的对象无关。也就是说它把所定义的对象置为顶层const。
  

  const int *p = nullptr;     //p是一个指向常量的普通指针constexpr int *q= nullptr;  //q是一个常量指针constexpr int i = 42;constexpr const *p = &i;

处理类型

• 类型别名（type alias）
  

• typedef
  <br>typedef double wages;   //wages是double的同义词 <br>typedef wages base, *p; //base是double的同义词，p是double*的同义词 <br>

• 别名声明（alias declaration）
  <br>using S1 = Sales_item;  //S1是Sales_item的同义词 <br>

• auto类型说明符
  

• 让编译器替代我们去分析表达式所属的类型。

• auto一般会忽略顶层const
  <br>const int i =1;     //i是整型常量 <br>auto b = i;         //b是一个整数 <br>const auto c = i;   //c是整型常量 <br>

• decltype类型指示符

  const int ci = 0, &cj = ci; 
  decltype(ci) x = 0;         //x的类型是const intdecltype(cj) y = x;         //y的类型是const int&，y绑定到变量xdecltype(cj) z;             //错误：z是一个引用，必须初始化

  int i = 42, *p = &i, &r = i;
  decltype(r + 0) b;  //正确：加法的结果是int，因此b是一个未初始化的intdecltype(*p) c;     //错误：c是int&，必须初始化

• decltype((v))(注意双层括号)的结果永远是引用。

• decltype处理顶层const和引用的方式与auto有些许不同。如果decltype使用的表达式是一个变量，则decltype返回该变量的类型（包括顶层const和引用在内）。

自定义数据结构

• 头文件通常包含哪些只能被定义一次的实体，如类、const和constexpr变量等。

• 预处理器（preprocessor）：如#include，当预处理器看到#include标记时就会用指定的头文件内容替代#include。

• 头文件保护符（header guard）:有效防止重复包含发生
  

• 一般把预处理变量的名字全部大写
  <br>#ifdef      //当且仅当变量已定义时为真 <br>#ifndef     //当且仅当变量未定义是为真 <br>#define     //把一个名字设定为预处理变量 <br>#endif      //与#ifdef和#ifndef匹配，执行它们的后续操作知道#endif指令止 <br>

#ifndef SALES_DATA_H#define SALES_DATA_H#include <string>struct Sales_data {    ... //此处省略
}；#endif

参考：C++Primer第五版

介绍语言的基本知识和标准库

相关文章：

第一章C++：函数返回值、GNU编译器命令

第三章C++：字符串string、向量vector和数组

Das obige ist der detaillierte Inhalt vonKapitel 2 C++: Variablen und Grundtypen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!