两小时回顾c++基础

最新推荐文章于 2024-09-18 09:20:14 发布

Shmily_Young

最新推荐文章于 2024-09-18 09:20:14 发布

阅读量493

点赞数 1

分类专栏： c++ 文章标签： c++ c++分章节知识点总结

本文链接：https://blog.csdn.net/shmilyforyq/article/details/72256075

版权

c++ 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

回顾一下，容易忘记的c++的一些需要注意，而往往会忽视的点。
标识符
C++ 标识符内不允许出现标点字符，比如 @、$ 和 %。C++ 是区分大小写的编程语言。
标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

这里写图片描述

下面代码会输出电脑上各种数据类型的大小。

#include <iostream>
using namespace std;

int main()
{
   cout << "Size of char : " << sizeof(char) << endl;
   cout << "Size of int : " << sizeof(int) << endl;
   cout << "Size of short int : " << sizeof(short int) << endl;
   cout << "Size of long int : " << sizeof(long int) << endl;
   cout << "Size of float : " << sizeof(float) << endl;
   cout << "Size of double : " << sizeof(double) << endl;
   cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
   return 0;
}

我的计算机上面输出的结果如下，不同计算机结果可能不同。
Size of char : 1
Size of int : 4
Size of short int : 2
Size of long int : 8
Size of float : 4
Size of double : 8
Size of wchar_t : 4

枚举类型
枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。
如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓”枚举”是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。
例如，下面的代码定义了一个颜色枚举，变量 c 的类型为 color。最后，c 被赋值为 “blue”。

enum color { red, green=5, blue } c;
c = blue;

默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。也可以给名称赋予一个特殊的值，只需要添加一个初始值即可，如上面blue=6，默认情况下，每个名称都会比它前面一个名称大 1。

变量
在程序中，局部变量和全局变量的名称可以相同，但是在函数内，局部变量的值会覆盖全局变量的值。
当局部变量被定义时，系统不会对其初始化，须自行对其初始化。定义全局变量时，系统会自动初始化。

常量

如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L’x’），此时它必须存储在 wchar_t
类型的变量中。否则，它就是一个窄字符常量（例如 ‘x’），此时它可以存储在 char 类型的简单变量中。
定义成 const 后的常量，程序对其中只能读不能修改。

C++ 允许使用速记符号来声明无符号短整数或无符号长整数。可以不写 int，只写单词 unsigned、short 或 unsigned、long，int 是隐含的。

这里写图片描述

存储类定义
1. auto ：从 C++ 11 开始，auto 关键字不再是 C++ 存储类说明符，且 register 关键字被弃用。自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。
2. register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。
3. static 存储类指示编译器在程序的生命周期内保持局部变量的存在，（局部->函数内，全局->文件内）
4. extern 是用来在另一个文件中声明一个全局变量或函数
5. mutable 说明符仅适用于类的对象，允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改
6. thread_local 说明符声明的变量仅可在它在其上创建的线程上访问，可以与 static 或 extern 合并。 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

#include< iostream.h> 和 #include< iostream>的区别
#include< iostream.h> 中不存在类 std，但是他有 cin,out 的相关函数，不需要使用命名空间了。
而第二种标准 #include< iostream>,它包含了一个类，在类的使用之前要预处理一下，using namespace std; 然后你就可以使用 cin,cout 这两个成员函数了，假设你不使用预处理 using namespace std;,就要加上 std::cin 或者 std::cout再去使用它的成员函数（头文件中存在这个类）

运算符
这里写图片描述

在函数声明中，参数的名称并不重要，只有参数的类型是必需的。

数学中的常用函数
这里写图片描述

C++ 随机数
在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。
下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数：

#include <iostream>
#include <ctime>
#include <cstdlib>

using namespace std;

int main ()
{
   int i,j;

   // 设置种子
   srand( (unsigned)time( NULL ) );

   /* 生成 10 个随机数 */
   for( i = 0; i < 10; i++ )
   {
      // 生成实际的随机数
      j= rand();
      cout <<"随机数： " << j << endl;
   }

   return 0;
}

思考：rand()生成的随机数，大小和位数能不设定？

数组

#include <iostream>
using namespace std;

#include <iomanip>
using std::setw;

int main ()
{
   int n[ 10 ]; // n 是一个包含 10 个整数的数组

   // 初始化数组元素          
   for ( int i = 0; i < 10; i++ )
   {
      n[ i ] = i + 100; // 设置元素 i 为 i + 100
   }
   cout << "Element" << setw( 13 ) << "Value" << endl;   //setw() 函数来格式化输出

   // 输出数组中每个元素的值                     
   for ( int j = 0; j < 10; j++ )
   {
      cout << setw( 7 )<< j << setw( 13 ) << n[ j ] << endl;
   }

   return 0;
}

结果：

Element        Value
      0          100
      1          101
      2          102
      3          103
      4          104
      5          105
      6          106
      7          107
      8          108
      9          109

Array 是固定大小的，不能额外增加元素.当我们想定义不固定大小的字符时,可以使用 vector(向量) 标准库。

#include <iostream>
#include <vector>
using namespace std;

int main() {
   // 创建向量用于存储整型数据
   vector<int> vec; 
   int i;

   // 显示 vec 初始大小
   cout << "vector size = " << vec.size() << endl;

   // 向向量 vec 追加 5 个整数值
   for(i = 0; i < 5; i++){
      vec.push_back(i);
   }

   // 显示追加后 vec 的大小
   cout << "extended vector size = " << vec.size() << endl;

   return 0;
}

vec的大小随着 for 循环的输入而增大。
执行以上代码，输出结果：

vector size = 0
extended vector size = 5

C++ 中有大量的字符串函数：（这些字符串是以 null 结尾的）

这里写图片描述

C++ 标准库也提供了 string 类类型（面向对象），可以不用char str[]来初始化,而是用 string str。如下所示：

#include <iostream>
#include <cstring>

using namespace std;

int main ()
{
   char str1[11] = "Hello";
   char str2[11] = "World";
   char str3[11];
   int  len ;

   // 复制 str1 到 str3
   strcpy( str3, str1);
   cout << "strcpy( str3, str1) : " << str3 << endl;

   // 连接 str1 和 str2
   strcat( str1, str2);
   cout << "strcat( str1, str2): " << str1 << endl;

   // 连接后，str1 的总长度
   len = strlen(str1);
   cout << "strlen(str1) : " << len << endl;

   return 0;
}

#include <iostream>
#include <string>

using namespace std;

int main ()
{
   string str1 = "Hello";
   string str2 = "World";
   string str3;
   int  len ;

   // 复制 str1 到 str3
   str3 = str1;
   cout << "str3 : " << str3 << endl;

   // 连接 str1 和 str2
   str3 = str1 + str2;
   cout << "str1 + str2 : " << str3 << endl;

   // 连接后，str3 的总长度
   len = str3.size();
   cout << "str3.size() :  " << len << endl;

   return 0;
}

c++输入输出流
除了cin和cout，我们来认识一下cerr和clog.

预定义的对象 cerr 是 ostream 类的一个实例。cerr 对象附属到标准错误设备，通常也是显示屏，但是 cerr
对象是非缓冲的，且每个流插入到 cerr 都会立即输出。cerr 也是与流插入运算符 << 结合使用的，如下所示：

#include <iostream>

using namespace std;

int main( )
{
   char str[] = "Unable to read....";

   cerr << "Error message : " << str << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

Error message : Unable to read....

2.预定义的对象 clog 是 ostream 类的一个实例。clog 对象附属到标准错误设备，通常也是显示屏，但是 clog 对象是缓冲的。这意味着每个流插入到 clog 都会先存储在缓冲区，直到缓冲填满或者缓冲区刷新时才会输出。
clog 也是与流插入运算符 << 结合使用的，如下所示：

#include <iostream>

using namespace std;

int main( )
{
   char str[] = "Unable to read....";

   clog << "Error message : " << str << endl;
}

当上面的代码被编译和执行时，它会产生下列结果：

Error message : Unable to read....

访问结构成员，我们使用成员访问运算符（.），如：

cout << "第一本书标题 : " << Book1.title <<endl;

指针—指向结构的指针
定义指向结构的指针，方式与定义指向其他类型变量的指针相似，如下所示：

struct Books *struct_pointer;

现在，可以在上述定义的指针变量中存储结构变量的地址。为了查找结构变量的地址，请把 & 运算符放在结构名称的前面，如下所示：

struct_pointer = &Book1;

为了使用指向该结构的指针访问结构的成员，您必须使用 -> 运算符，如下所示：

struct_pointer->title;

如下结构体和指向结构体的指针两个实例所示：

#include <iostream>
#include <cstring>

using namespace std;
void printBook( struct Books book );

// 声明一个结构体类型 Books 
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

int main( )
{
   Books Book1;        // 定义结构体类型 Books 的变量 Book1
   Books Book2;        // 定义结构体类型 Books 的变量 Book2

    // Book1 详述
   strcpy( Book1.title, "C++ 教程");
   strcpy( Book1.author, "ABC"); 
   strcpy( Book1.subject, "编程语言");
   Book1.book_id = 12345;

   // Book2 详述
   strcpy( Book2.title, "C 教程");
   strcpy( Book2.author, "ABC");
   strcpy( Book2.subject, "后台语言");
   Book2.book_id = 12346;

   // 输出 Book1 信息
   printBook( Book1 );

   // 输出 Book2 信息
   printBook( Book2 );

   return 0;
}
void printBook( struct Books book )
{
   cout << "书标题 : " << book.title <<endl;
   cout << "书作者 : " << book.author <<endl;
   cout << "书类目 : " << book.subject <<endl;
   cout << "书 ID : " << book.book_id <<endl;
}

#include <iostream>
#include <cstring>

using namespace std;
void printBook( struct Books *book );

struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
};

int main( )
{
   Books Book1;        // 定义结构体类型 Books 的变量 Book1
   Books Book2;        // 定义结构体类型 Books 的变量 Book2

    // Book1 详述
   strcpy( Book1.title, "C++ 教程");
   strcpy( Book1.author, "ABC"); 
   strcpy( Book1.subject, "编程语言");
   Book1.book_id = 12345;

   // Book2 详述
   strcpy( Book2.title, "C 教程");
   strcpy( Book2.author, "ABC");
   strcpy( Book2.subject, "后台语言");
   Book2.book_id = 12346;

   // 通过传 Book1 的地址来输出 Book1 信息
   printBook( &Book1 );

   // 通过传 Book2 的地址来输出 Book2 信息
   printBook( &Book2 );

   return 0;
}
// 该函数以结构指针作为参数
void printBook( struct Books *book )
{
   cout << "书标题  : " << book->title <<endl;
   cout << "书作者 : " << book->author <<endl;
   cout << "书类目 : " << book->subject <<endl;
   cout << "书 ID : " << book->book_id <<endl;
}