资讯详情

C++知识点总结

  • C 完全支持面向对象的程序设计，包括面向对象开发的四个特点：（
  • 标准的 C 由三个重要部分组成：
    • ，包括变量、数据类型和常量在内的所有构件块，
    • ，操作文件和字符串提供了大量的函数
    • ，操作数据结构提供了大量的方法

  • IDE编程步骤

    • ①:手敲代码

    • ②:编译源代码，相当于翻译，把你的C 语言C语言翻译给计算机听，即告诉计算机机器语言，当然也是代码，这里翻译的代码被称为目标代码，这一步也处理了预处理器中包含的指令

    • ③:源代码由编译器编译

    • ④程序=启动代码 库代码 目标代码,您的程序可能需要调用许多其他代码来帮助您完成任务，因此需要链接它们，集成代码是可执行代码

    • ⑤,最终代码是程序运行时的代码

  • 包括（Windows Notepad）、（OS Edit command）、（Brief）、（Epsilon）、（EMACS） 和（ vim/vi）

    • 在不同的操作系统中，文本编辑器的名称和版本可能会有所不同。（）通常用于 在操作系统上，（可用于 Windows 和 操作系统。

  • C 程序的源文件通常使用 .cpp、.cp 或 .c）,大多数的 C 编译器不在乎源文件的扩展名，但如果没有指定扩展名，。

  • 源代码写在源文件中是人类可读源。"编译"，这样转化为机器语言 CPU 程序可按给定指令执行。

  • C 编译器用于将源代码编译成最终可执行程序。

  • 最常用的免费可用编译器是的

    • 假如你用的是，请使用以下命令检查您的系统是否安装在命令行上 ：

    • 假如你用的是 ，获得最快 GCC 下载苹果网站的方法是 Xcode 根据安装说明，开发环境并安装。一旦安装 您就能使用 GNU 编译器。

    • 为了在 上安装 GCC，您需要安装 。为了安装 MinGW，请访问 MinGW 的主页www.mingw.org，进入 MinGW 下载页面，下载最新版本 MinGW 安装程序，命名格式 MinGW-.exe。当安装 MinGW 至少要安装 ，但通常会安装更多其他项目。添加您安装的内容 MinGW 的 bin 子目录到你的环境变量中，这样您就可以在命令行中通过简单的名称来指定这些工具。当完成安装时，您可以从 Windows 命令行上运行 gcc、g 、ar、ranlib、dlltool 和其他一些 GNU 工具。

  • C 扩展名往往是.cpp在linux中往往是.cxx,目标代码文件是.o可执行文件是.out

  • 是一种规范，描述您设计的新数据结构，对象是类的实现，即根据该规范构建的数据结构，换句话说，,对象是根据这些描述创建的实体

  • 函数可以来自函数库,类也有类库，ostream和istream系列类是一种类库fstream系列类别不好，我们更喜欢叫系列类别

  • 预处理器

    • 什么是预处理器？在主编译之前，您不需要进行特殊操作来调用源文件，只需要#

    • 使用编译指令，如#include 就是把iostream在编译源代码之前，将文件添加到程序中是一个典型的预处理器操作，替换或添加文本

    • #include指令会把iostream文件中的内容和源代码一起发送给编译器，具体是iostream所有文件将被取代#include 这一行代码生成了一个新的复合文件，而不是修改源代码文件

  • 头文件=包含文件

    • iostream这种文件被称为包含文件(通常是include其含在其他文件中) ,也叫头文件(通常在程序开始时)

    • C 有许多头文件，每个头文件都带来了一组特定的工具

    • C不同的文件类型用不同的扩展名表示，C 取消所有扩展名

    • ,你可以掌握很多知识，这是个好习惯

  • 名称空间

    • 上述头文件文件.h其实没那么简单，但是没有.h头文件包含名称空间

    • 名称空间编译指令usingnamespace 比如usingnamespacestd;这里是using编译指令

      • 打断一下，你现在知道了两个编译指令，一个是using一个是#include

    • 头文件包含名称空间，,以下两种方式访问他们std为例

      • ; //通过using声明了编译指令cout的来源是std名称空间

      • ; cout<<'a'<

  • cout它知道如何显示字符串、数字和字符等数据

    • cout它是一个对象，它是什么样的对象？

    • 插入运算符<<符号可以将信息流入cout中即cout<<'a'

    • cout<<'a将字符a从程序中流出，而cout表示这种输出流，cout对象的具体属性是iostream头文件中定义的,属性包括了一个插入运算符<<,可将数据插入输出流

  • 控制符endl,如果控制符被重启，则表示重启一行endl也插入输出流，然后你的屏幕光标会（,endl控制符也是iostream头文件中定义的,同样名字也在std名称空间中

    • cout代表了输出流,所以并不能移动光标

    • cout是指代表了输出流,所以也不能产生空格,如果你需要空格,那就把空格插入到输出流中吧

  • C++程序可以看成一组函数, 而每个函数又是一组语句

  • 创建了变量,作用就是:指出了（信息存储的具体位置）和（需要的内存空间大小）

    • (计算机存储数据时,必须要知道数据的存储位置和所占内存空间大小)

    • 声明语句提供了（存储类型）和（位置标签）,位置标签表示了具体位置,存储类型则代表了所占内存空间的大小信息

      • 比如int num; int是整数类型,根据计算机系统不同,整数类型所占的内存空间(位数或字节数)也不同,而num则代表了上述内存空间的位置标签,num作为变量是可以改变的,就是内存空间存储的信息是可以修改的

      • 不同的数据类型,则代表了不同的内存空间占用的大小数量

    • 你不需要管这些底层的事情,编译器会帮你分配好内存并标记好位置

    • 对于变量而言：

      • 变量的声明，指出存储位置和所需空间大小

      • 变量的定义，指出存储位置和所需空间大小，且申请相应内存空间

    • 对于函数而言：

      • 函数的声明，相当于变量声明于变量，声明函数原型

      • 函数的定义，给出函数的结构体

思考：声明、定义、引用三者各什么意思？是否有什么联系？？

  • 赋值语句=赋值运算符则可以对内存空间中存储的数据进行修改

  • 代表输入流的cin对象,为cin提供了流入方向

  • 换行符\n, 换行符常用在字符串中,其实\n是一个字符,名称是换行符而已,

  • 换行符\n和控制符endl的区别

    • 显然是字符数量少了\n两个endl四个

    • 当然如果你只想要一个空行,两者都可以选择

      • cout<

      • cout<<"\n";

  • , 所以你在一条语句中使用多少回车都是无法表示该语句的结束的,甚至是没有什么影响,所以在一条语句中,回车的作用=空格=制表符(多个空格)

    • 这并不意味着你可以随意使用多个空格或者回车, 无论是C还是C++你都不能把空格,制表符,回车,放到元素中(比如变量名), 也不能放到字符串中,这很重要,cout<<"字符串中不能添加回车,不要换行"

  • 标记和空白

    • 一行代码中不可分割元素比如int 比如main等,都叫做标记,通常我们用空格制表符回车把两个标记分开({}就是用回车分开的)

    • 有些可以通过一个空格来分开,有些不可以,比如 int main()你不要把回车插入到int和main中间

基础语法篇

  • C++ 程序可以定义为（对象）的集合，这些对象通过（调用）的方法进行交互。现在让我们简要地看一下什么是类、对象，方法、即时变量。
    •  对象。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
    •  类可以定义为描述对象（）。
    •  从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
    •  每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。

  • 。也就是说，每个语句必须以分号结束。它表明一个逻辑实体的结束。

  • 。一个标识符以字母 A-Z 或 a-z 或下划线 _ 开始，后跟零个或多个字母、下划线和数字（0-9）。

  • C++ 注释以 /* 开始，以 */ 终止。注释也能以 // 开始，直到行末为止。

类型 位 范围
-128 到 127 或者 0 到 255
unsigned char 1 个字节 0 到 255
signed char 1 个字节 -128 到 127
-2147483648 到 2147483647
unsigned int 4 个字节 0 到 4294967295
signed int 4 个字节 -2147483648 到 2147483647
short int 2 个字节 -32768 到 32767
unsigned short int 2 个字节 0 到 65,535
signed short int 2 个字节 -32768 到 32767
long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
signed long int 8 个字节 -9,223,372,036,854,775,808 到 9,223,372,036,854,775,807
unsigned long int 8 个字节 0 to 18,446,744,073,709,551,615
+/- 3.4e +/- 38 (~7 个数字)
+/- 1.7e +/- 308 (~15 个数字)
long double 16 个字节 +/- 1.7e +/- 308 (~15 个数字)
wchar_t 2 或 4 个字节 1 个宽字符

  • unsigned或signed改变范围不改变字节数, short 字节 *0.5, long字节*2,如short int 则字节为2, long int 字节为8

  • 使用 （ 为（一个已有的类型取）一个新的名字

  • 使用 （ 函数来获取各种数据类型的大小。

  • 返回类型或变量长度,单位是B字节

    • 对变量操作时, 无需加括号,即int a = 0 ; cout<

    • 对数据类型操作时,加括号,即cout<

    • sizeof运算符对指针进行操作时,得到的是指针的长度,即使指针指向的是个数组

    • 枚举类型(enumeration)是C++中的一种派生数据类型，它是由用户定义的若干枚举常量的集合.如果一个变量只有几种可能的值，可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举出来，变量的值只能在列举出来的值的范围内。

    • 创建枚举，需要使用关键字 。

    • 默认情况下，第一个名称的值为 0，第二个名称的值为 1，第三个名称的值为 2，以此类推。但是，您也可以给名称赋予一个特殊的值，只需要添加一个初始值即可。例如，在下面的枚举中， 的值为 5。

    • 在这里，blue 的值为 6，因为默认情况下，每个名称都会比它前面一个名称大 1，但 red 的值依然为 0。

    • 代码中是两种不同的创建枚举的方法,第一种方法,name, age,width,height的值,是其下标值,如age下表是1,则age=1;

    • 第二种方法,直接赋值,age就是18

    • 注意,枚举的各个元素都是符号常量,并且指定的具体数值必须是整数,当然第一种情况默认赋值必然是整数

/*
enum 枚举名{ 
     标识符[=整型常数], 
     标识符[=整型常数], 
... 
    标识符[=整型常数]
} 枚举变量;
*/

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

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

enum person {name, age, width, height};
enum person0 {name = 1, age = 18, width =120, height=133232};

  • 变量的名称可以由（、和字符组成。它必须以（。大写字母和小写字母是不同的，因为 C++ 是。
类型 描述
bool 存储值 true 或 false。
char 通常是一个字符（八位）。这是一个整数类型。
int 对机器而言，整数的最自然的大小。
float 单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数。图片说明
double 双精度浮点值。双精度是1位符号，11位指数，52位小数。
void 表示类型的缺失。
wchar_t 宽字符类型。

使用（  关键字）在任何地方一个变量

  • 指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
  • 术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

  • 强制类型转换(这里是简单地类型转换,还有更高级的操作在fstream类中)

    • 运算符是强制类型转换符

    • static_cast (xjh)把xjh变量强制转换成int类型

    • 变量声明=提供名字+存储类型,
    • 变量定义=提供名字+存储类型+申请内存空间
    • extern外部声明
    • // 变量声明
extern int a, b;
extern int c;
extern float f;

// 函数声明
int func();

int main ()
{
  // 变量定义
  int a, b;
  int c;
  float f;
 
  // 实际初始化
  a = 10;
  b = 20;
  c = a + b;
 
  cout << c << endl ;
 
  f = 70.0/3.0;
  cout << f << endl ;

  // 函数调用
  int i = func();
 
  return 0;
}



// 函数定义
int func()
{
    return 0;
}

如果只声明不定义会怎么样呢?

#include <iostream>
extern int a;
int main(void)
{       
        extern int b;
        int a =0;
        b=1;
        std::cout<<"a:"<<a<<",b:"<<b<<std::endl;
	return 0;
}  




>>>g++ main.cpp
/tmp/cctOXSfB.o: In function `main':
main.cpp:(.text+0x11): undefined reference to `b'
main.cpp:(.text+0x50): undefined reference to `b'
collect2: error: ld returned 1 exit status

常量

  • 在 C++ 中，有两种简单的定义常量的方式：

    • 使用  预处理器。

      • 预处理编译指令#define这里举个例子来说明

        • #define INT_MAX 32767

        • 编译指令#define在编译前在程序中查找所有的INT_MAX，然后用32767替换。完成替换后，程序会被编译

        • 当然预处理器仅仅替换独立的标记，而不会替换嵌入INT_MAX的标记，如PINT_MAX或UINT_MAX

    • 使用  关键字。
      • ：会进行类型安全检查。而define没有安全检查，且可能会产生意料不到的错误。

  • 整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：。

  • 整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。
#include <iostream>
using namespace std;

#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'

int main()
{

   int area;  

   area = LENGTH * WIDTH;
   cout << area;
   cout << NEWLINE;
   
   const int NUMBER = 10;
   const float PRICE= 13.23;
   double output = NUMBER * PRICE;
   cout << output;
   return 0;
}

/*
212         // 合法的
215u        // 合法的
0xFeeL      // 合法的
078         // 非法的：8 不是八进制的数字
032UU       // 非法的：不能重复后缀
85         // 十进制
0213       // 八进制 
0x4b       // 十六进制 
30         // 整数 
30u        // 无符号整数 
30l        // 长整数 
30ul       // 无符号长整数
*/
  • 浮点常量
    • 由整数部分、小数点、小数部分和指数部分组成。如3.14
      • 当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。
      • 当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。
      • 带符号的指数是用 e 或 E 引入的。
3.14159       // 合法的 
314159E-5L    // 合法的 
510E          // 非法的：不完整的指数
210f          // 非法的：没有小数或指数
.e55          // 非法的：缺少整数或分数

转义字符

转义序列 含义
\ \ 字符
' ' 字符
" " 字符
? ? 字符
\a 警报铃声
\b 退格键 back
\f 换页符 form feed 换页
\n 换行符 newline换行
\r 回车 return
\t 水平制表符
\v 垂直制表符
\ooo 一到三位的八进制数
\xhh . . . 一个或多个数字的十六进制数

引用 &

  • 引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。

    • 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。（引用不可二次多次指向，指针可以）
    • 引用必须在创建时被初始化。指针可以在任何时间被初始化。
  • 变量名称是变量附属在内存位置中的标签，可以把当成附属在内存位置中

#include <iostream>

using namespace std;

int main ()
{
   // 声明简单的变量
   int    i;
   double d;

   // 声明引用变量
   int&    r = i;
   double& s = d;

   i = 5;
   cout << "Value of i : " << i << endl;
   cout << "Value of i reference : " << r  << endl;

   d = 11.7;
   cout << "Value of d : " << d << endl;
   cout << "Value of d reference : " << s  << endl;

   return 0;
}
  • 在这些声明中，& 读作。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。

存储类

  • 存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。说明符放置在它们所修饰的类型之前

  • auto 存储类,  关键字用于两种情况：声明变量时根据初始化表达式。

可以使用STL中的 typeid(auto_name).name()来查看类型名

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一

cout<<typeid(x1).name()<<endl;

  •  存储类用于定义而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 '&' 运算符（因为它没有内存位置）。

    • 寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 'register' 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

  •  存储类指示编译器的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

    • 当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

    • 当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

  •  存储类用于提供一个的引用，全局变量对所有的程序文件都是可见的。

    • 当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。

    • extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，

//File0

#include <iostream>

int count ;
extern void write_extern();

int main()
{
   count = 5;
   write_extern();
}

//File1

#include <iostream>

extern int count;

void write_extern(void)
{
   std::cout << "Count is " << count << std::endl;
}

运算符

运算符 描述 实例
+ 把两个操作数相加 A + B 将得到 30
- 从第一个操作数中减去第二个操作数 A - B 将得到 -10
* 把两个操作数相乘 A * B 将得到 200
/ 分子除以分母 B / A 将得到 2
B % A 将得到 0
++

自增运算符,整数值增加 1

 A++ 将得到 11
--

自减运算符，整数值减少 1

 A-- 将得到 9
&&

称为逻辑与运算符。如果两个操作数都非零，则条件为真。

 (A && B) 为假。
||

称为逻辑或运算符。如果两个操作数中有任意一个非零，则条件为真。

 (A || B) 为真。
!

称为逻辑非运算符。用来逆转操作数的逻辑状态。如果条件为真则逻辑非运算符将使其为假。

 !(A && B) 为真。
sizeof

sizeof 运算符返回变量的大小。例如，sizeof(a) 将返回 4，其中 a 是整数。
Condition ? X : Y

条件运算符。如果 Condition 为真 ? 则值为 X : 否则值为 Y。
,

逗号运算符会顺序执行一系列运算。整个逗号表达式的值是以逗号分隔的列表中的最后一个表达式的值。
.（点）和 ->（箭头）

成员运算符用于引用类、结构和共用体的成员。
Cast

强制转换运算符把一种数据类型转换为另一种数据类型。例如，int(2.2000) 将返回 2。
&

指针运算符 & 返回变量的地址。例如 &a; 将给出变量的实际地址。
*

指针运算符 * 指向一个变量。例如，*var; 将指向变量 var。

 

int a = 0;
int b = 0;
a++;
cout<<a;
cout<<b++;
cout<<b;

//输出
1
0
1

循环与判断

  • 循环控制语句
    • break 终止  或  语句，程序流将继续执行紧接着 loop 或 switch 的下一条语句。
    • continue 引起循环跳过主体的剩余部分，立即重新开始测试条件.
  • 判断语句(拿python笔记充数,逻辑是同样的)

  • ? : 运算符 可以用来替代  语句。

Exp1 ? Exp2 : Exp3;
  • 如果 Exp1 为真，则计算 Exp2 的值，结果即为整个表达式的值。如果 Exp1 为假，则计算 Exp3 的值

函数参数

  • 如果函数要使用参数，则必须声明接受参数值的变量。这些变量称为函数的。

    当调用函数时，有两种向函数传递参数的方式：

传值调用 该方法把。在这种情况下，修改函数内的形式参数对实际参数
指针调用 该方法把。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数实际参数。
引用调用 该方法把。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数实际参数。
  • 当您定义一个函数，您可以为参数列表中后边的每一个参数指定默认值。当调用函数时，如果实际参数的值留空，则使用这个默认值。

  • C++ 内置了丰富的数学函数，可对各种数字进行运算。下表列出了 C++ 中一些有用的内置的数学函数。为了利用这些函数，

序号 函数 & 描述
1  该函数返回弧度角（double 型）的余弦。
2  该函数返回弧度角（double 型）的正弦。
3  该函数返回弧度角（double 型）的正切。
4  该函数返回参数的自然对数。
5  假设第一个参数为 x，第二个参数为 y，则该函数返回 x 的 y 次方。
6  该函数返回，也就是说，参数为一个直角三角形的两个直角边，函数会返回斜边的长度。
7  该函数返回参数的。
8  该函数返回整数的绝对值。
9  该函数返回任意一个浮点数的绝对值。
10  该函数返回一个小于或等于传入参数的最大整数。 
#include <iostream>
#include <cmath>
using namespace std;

int main ()
{
   // 数字定义
   short  s = 10;
   int    i = -1000;
   long   l = 100000;
   float  f = 230.47;
   double d = 200.374;

   // 数学运算
   cout << "sin(d) :" << sin(d) << endl;
   cout << "abs(i)  :" << abs(i) << endl;
   cout << "floor(d) :" << floor(d) << endl;
   cout << "sqrt(f) :" << sqrt(f) << endl;
   cout << "pow( d, 2) :" << pow(d, 2) << endl;

   return 0;
}

随机数

  • 随机数生成器，有两个相关的函数。一个是 ，该函数只返回一个伪随机数。生成随机数之前必须先调用  函数。

  • 下面是一个关于生成随机数的简单实例。实例中使用了  函数来获取系统时间的秒数，通过调用 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;
}

  • C++ 支持数据结构，它可以存储一个的元素的集合。

  • 如何数组声明?

typeName arrayName[arraySize]; 

  • 其中typeName是你元素类型, arrayName是你的自定义数组名,arraySize是你自定义数组长度()即元素总个数

  • 举例说明数组的复合意义?float xjh[1228]; 这里的xjh类型不是数组,而是float数组, 要这么说:"你要建立一个int数组或者float数组"

  • 数组从0开始索引并用[下标]来索引

  • 数组赋值也不被允许,即int xjh[3] = {1,2,2,8};int xjh1[3] = {1,2,2,8};xjh1 = xjh;这种操作不被允许,只能通过下标访问元素来对某个元素进行赋值,修改等

  • 所有的数组都是由连续的内存位置组成。最低的地址对应第一个元素，最高的地址对应最后一个元素。

  • 声明数组，需要指定和，type arrayName [ arraySize ];

    • 这叫做一维数组。 必须是一个大于零的整数常量， 可以是任意有效的 C++ 数据类型。

  • 初始化数组

    • 可以逐个初始化数组，也可以使用一个初始化语句

    •  double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

      大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目

    • 如果您

      double balance[] = {1000.0, 2.0, 3.4, 7.0, 50.0};

      • 注意,若int xjh[3]; 然后再xjh[3] = {1,2,2,8};则不被允许

  • 数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。

  • int array[3] = {1,2,3};
int array1 = array;

    二维数组

  • int data[3][4] = {
      
        {1,2,3,4}, {5,6,7,8}, {1,2,3,4}};
int (*data)[4];

    先看data，显然我们知道data是个数组名，也是个指针，常规的int data[];是说data是个int数组，data也是个指向int类型的指针

  • 这里的data是什么呢？ ，这个指针指向的是个数组，这个数组是由4个int类型元素构成的，即int （*data)  [4] ;这样太晦涩难懂了， 也可以这样int data[][4];意义完全相同，这里都表明了data不是数组而是指针

思路:

        1⃣️int data[][3];可以看成int (*data)[3],即data是个指针,指向一个包含了3个int的数组

        2⃣️指针完全可以用作数组名,例如int* ptr; ptr[1];,那么data则可以当做数组名,从而int data[][3];

  • 这里明白了，那么如何传递数组的长度呢？

    • 显然int data[][4]对行数是没有限制的，只是明确了列数要是4，即data指针指向的每个数组长度是4

  • 同样的，函数对C风格字符串没有办法传递和返回，我们直接用string更合适

  • 函数指针，函数指针这里交给指针笔记记录

    • double (*ptr)[4];
double arr[][4];

// arr[][4] 换一个写法 (*arr)[4]
//(*ptr)[4] 完全可以把ptr当成数组名来使用 ptr[][4]

字符串

基于数组的字符串即C-style stringC⻛格字符串 

  • 字符串实际上是使用  字符 '\0' 终止的一维字符数组。因此，一个以 null 结尾的字符串，包含了组成字符串的字符。
  • char greeting[6] = {'H', 'e', 'l', 'l', 'o', '\0'};
char greeting[] = "Hello";
//上述两个语句是一样的效果

字符串处理函数
序号 函数 & 目的
1  复制字符串 s2 到字符串 s1。
2  连接字符串 s2 到字符串 s1 的末尾。
3  返回字符串 s1 的可见长度。(不包含NULL字符,即'\0')
4  如果 s1 和 s2 是相同的，则返回 0；如果 s1s2 则返回值大于 0。
5  返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6  返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。
7 ;返回整个数组的长度,包括任何字符
  • 'S'是字符常量,相当于83的另一个写法
  • "S"是字符串,字符串"S"双引号表示,他是两个字符,即'S'和'\0',而且,"S"表示的其实是字符串所在的内存地址(地址在C++中是一个独立类型,你要用这种眼光去审视地址)
    • 从输入队列中读取输入内容, 遇到换行符停止读取,
      • getline(name,20) 读取19个元素和一个换行符
    • 从输入队列中读取输入内容,遇到换行符停止读取,同时
      • 如果想提出换行符,可以利用空参数的cin.get(),它可以读取任何字符,用它来处理换行符,为下一行做准备

char arr[100];
cout<<"输入一段文字:"<<endl;
cin.getline(arr,20);       //使用getline
cin.get(arr,20);         //使用get

get与getline有两个参数，第一个参数是用来存储的数组名称，第二个参数代表着读取的字节数。

输入：asdfg 回车

get：只读取asdfg不读取回车，会导致下一个读取输入时第一个读取“回车”。

getline：getline读取asdfg回车，并将回车转换为“\0”读取，所以最终读取的是“asdfg\0”输入序列中无回车，下一个读取将会正常读取。

  • 字符串输入,cin对象的解释

    • cin对象通过使用空白,即空格,制表符(多个空格)换行符, 来确定字符串的结束位置, 这说明cin对象在输入流中每次只读取一个单词, 读取单词后就把它放到数组中并自动添加空字符

基于string类库的字符串

  • 首先你要包含string类库文件(头文件), string类的名称在标准名称空间std中,std::string即可完成引用

  • String类的对象来存储字符串,String类的设计让程序可以自动处理字符串的大小

  • 数组不能赋值,但是String类对象可以,string s1;string s2; s1=s2;是允许的

  • 还可以通过+来进行拼接合并,这里是无缝合并

  • 通过类方法.size()可以快速获得String类对象的长度

C++ 日期 & 时间

  • C++ 标准库没有提供所谓的日期类型。C++ 标准库没有提供所谓的日期类型。需要在 C++ 程序中引用 头文件。

指针

明确这一点，可以对包含指针的语句分析时，抽丝剥茧，快速理解复杂的语句。

成员访问的方法

A.B 直接成员运算符 

 A为对象或者结构体,访问A的成员B,若A是指针则不适用
A->B间接成员运算符 A为指针,->是成员提取,A->B是提取A中的成员B,且A只能是指向类,结构的指针
:: 作用域运算符,A::B表示作用域A中的名称B, A是命名空间,类,结构
: 表示继承
优先级（高到低）
:: 作用域解析

作用域解析最优先

小中括号是二三

成员访问后增减

地址后边解引用
() 小括号
[] 中括号,数组
-> 成员访问
++ 后缀自增
--
! 非
~ 位非
+ 正，加
-
++ 前缀自增
--
& 地址
* 解除引用（指针）
  • 指针是一个变量,存储的是地址信息
    • P的值是地址
    • *P的值是指向的数据值,完全可以把*P看成一个普通变量
  • 获取地址值&
    • 对于普通变量,想要获得该变量的地址,需要用,即表示的就是变量a的地址,和P一个意思
  • 运算符也被称为是
  • 声明指针
    • 指针的声明必须,指定指向的数据类型,如 int * p;
      • 这里的*p 的数据类型是int,
      • p是指向int类型的指针
double * p;    //定义声明了一个指向double类型的指针p
double* p;    //定义声明了一个指向double类型的指针p，强调p是指向double类型的指针变量
double *p;    //定义声明了一个指向double类型的指针p，强调*p是double类型
  • 指针初始化
    • Question: 初始化的是指针地址还是指针指向的数据值?
      • 初始化的是指针存储的地址
    • int *p = &a ;
  • &运算符注意点
    • （数组名=第一个元素的地址，无需&运算符）,虽然这两个地址是相同的,但是操作起来时会有明显差异,如下:
    • &array[2]得到的是一个2字节的内存块的地址值,而&array则是一个20个字节内存块的首地址

：栈区的空间由操作系统自动分配和释放，该部分主要用于存放函数的参数值、局部变量等，比如声明在函数中的一个局部变量int b，系统就会自动在栈中为b开辟空间。栈区的操作方式类似于数据结构中栈（这也许是造成许多人混淆的地方，正如有的人所说，我们可以把数据结构的栈理解成某个技术，而内存的栈正好用到了该技术，但二者其实并不一样）。另外需要注意的是,在windows下，栈是向低地址扩展的数据机构，是一块连续的内存区域。也就是说栈顶的地址和栈的最大容量是系统预先设定好的，比如在windows下，栈的大小为2MB（也有的说是1MB，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间，将会提示overflow。总之就是说栈的空间是有限的。

      ：堆区空间一般由程序员分配和释放（需要注意堆区与数据结构中的堆是两回事，其分配方式类似于链表），比如，在C中用malloc函数---  p1 = (char*) malloc(10);   在C++中用new，都将分配堆区空间。不过要注意p1本身是在栈中。

      ：全局变量和静态变量都存放于该区。初始化的全局变量和初始化的静态变量放在一块区域，未初始化的全局变量和未初始化的静态变量放在相邻的另一区域。程序结束后由系统自动释放。

      ：该区用于存放函数体的二进制代码。

    • 自动存储
      • 在函数内部定义或{}内的常规变量,使用自动存储空间,使用自动存储类型的变量叫自动变量,其使用的存储空间成为
      • 自动变量其实是局部变量,随函数调用诞生,结束消亡
      • 栈即LIFO后入先出
    • 静态存储
      • 程序执行期间都存在的存储方式,可以通过函数体or {} 外定义它,也可以通过声明变量时使用关键字static
      • 只要程序活着,静态变量就一直存在
    • 动态存储
      • 运算符new和delete管理

标签： pds矩形电连接器

锐单商城拥有海量元器件数据手册、 IC替代型号，打造 电子元器件IC百科大全！

锐单商城 - 一站式电子元器件采购平台