1.C++ 数组

声明和初始化

//一维数组
double balance[5] = {1000.0, 2.0, 3.4, 17.0, 50.0};//区别于java的常用方式int[] arr = new int[4];
//二维数组
int a[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};

指向数组的指针

double *p;
double balance[10];//数组名为指针

p = balance;//把 p 赋值为 balance 的第一个元素的地址
//*(balance + i)或者*(p + i) 都可以直接取数组中第i个元素的值

balance 是一个指向 &balance[0] 的指针，即数组 balance 的第一个元素的地址

传递数组给函数

三种方式

void myFunction(int *param)
void myFunction(int param[10])//大小随便写
void myFunction(int param[])
//三种方式结果是一样的，C++ 不会对形式参数执行边界检查

从函数返回数组

想要从函数返回一个一维数组，必须声明一个返回指针的函数
int * myFunction(){//...}

#include <iostream>
#include <cstdlib>
#include <ctime>
 
using namespace std;
 
// 要生成和返回随机数的函数
int * getRandom( )
{
  static int  r[10];
  // 设置种子
  srand( (unsigned)time( NULL ) );
  for (int i = 0; i < 10; ++i)
  {
    r[i] = rand();
  }
  return r; //数组名为指针
}
 
// 要调用上面定义函数的主函数
int main ()
{
   // 一个指向整数的指针
   int *p = getRandom() ;
   for ( int i = 0; i < 10; i++ )
   {
       cout << "*(p + " << i << ") : " << *(p + i) << endl;
   }
   return 0;
}

2. C++ 函数/方法

函数声明告诉编译器函数的名称、返回类型和参数。函数定义提供了函数的实际主体。

C++ 标准库提供了可以调用的内置函数。例如，函数 strcat() 用来连接两个字符串，函数 memcpy() 用来复制内存到另一个位置。

定义函数

int max(int num1, int num2) 
{
   int result;
   if (num1 > num2)
      result = num1;
   else
      result = num2;
   return result; 
}

声明函数/函数声明

针对上面定义的函数 max()：
int max(int num1, int num2);
在函数声明中，参数的名称并不重要，下面也是有效的声明：
int max(int, int);

C++ 指针运算符（& 和 *）

C++ 提供了两种指针运算符，一种是取地址运算符 &，一种是间接寻址运算符 *。
指针是一个包含了另一个变量地址的变量，您可以把一个 包含了另一个变量地址的变量 说成是"指向"另一个变量。变量可以是任意的数据类型，包括对象、结构或者指针。
* 是一元运算符，返回操作数所指定地址的变量的值

int main ()
{
   int  var;
   int  *ptr;
   var = 3000;
   ptr = &var;
   // 获取 ptr 的值
   val = *ptr;//3000
}

函数参数

调用类型	描述
传值调用	该方法把参数的实际值复制给函数的形式参数。在这种情况下，修改函数内的形式参数对实际参数没有影响。
指针调用	该方法把参数的地址复制给形式参数。在函数内，该地址用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。
引用调用	该方法把参数的引用复制给形式参数。在函数内，该引用用于访问调用中要用到的实际参数。这意味着，修改形式参数会影响实际参数。

指针和引用

指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。

1. 指针是一个实体，而引用仅是个别名；
2. 引用使用时无需解引用（*），指针需要解引用；
3. 引用只能在定义时被 **初始化一次** ，之后可以改变指向的对象，但是仍然指向初始化时的对象，即修改无效；指针可变； 
4. 引用可以有 const，且从一而终，不可改变指向的对象，即无实际意义，指针也有 const，指针常量不可改指向，常量指针可改变指向； 
5. 指针用操作符‘*’和‘->’，引用使用操作符‘.’

//以下程序中，n 是m 的一个引用（reference），m是被引用物（referent）。
    int m；
    int &n = m；
//n 相当于m 的别名（绰号），对n 的任何操作就是对m 的操作。

指针调用

// 函数定义
void swap(int *x, int *y)
{
   int temp;
   temp = *x;    /* 保存地址 x 的值 */
   *x = *y;        /* 把 y 赋值给 x */
   *y = temp;    /* 把 x 赋值给 y */
  
   return;
}
int main(){
   int a = 100;
   int b = 200;
   /* 调用函数来交换值
    * &a 表示指向 a 的指针，即变量 a 的地址 
    * &b 表示指向 b 的指针，即变量 b 的地址 
    */
   swap(&a, &b);
}

引用调用

// 函数定义
void swap(int &x, int &y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
  
   return;
}
int main(){
   int a = 100;
   int b = 200;
   /* 调用函数来交换值 */
   swap(a, b);
}

参数的默认值

//减少重载
int sum(int a, int b=20)
{
  int result;
  result = a + b;
  return (result);
}

Lambda 函数与表达式

Lambda函数的语法定义如下：

[capture捕捉列表](parameters参数列表) mutable修饰符 ->return-type返回类型{statement函数体}

3. C++ 字符串

C风格字符串

char greeting[] = "Hello";

C/C++ 中定义的字符串的内存表示

C++ 中的 String 类

#include <string>
string str1 = "Hello";

4. 常用函数

数字操作

#include <cmath>

序号	函数 & 描述
1	double cos(double);该函数返回弧度角（double 型）的余弦。
2	double sin(double);该函数返回弧度角（double 型）的正弦。
3	double tan(double);该函数返回弧度角（double 型）的正切。
4	double log(double);该函数返回参数的自然对数。
5	double pow(double, double);假设第一个参数为 x，第二个参数为 y，则该函数返回 x 的 y 次方。
6	double hypot(double, double);该函数返回两个参数的平方总和的平方根，也就是说，参数为一个直角三角形的两个直角边，函数会返回斜边的长度。
7	double sqrt(double);该函数返回参数的平方根。
8	int abs(int);该函数返回整数的绝对值。
9	double fabs(double);该函数返回任意一个十进制数的绝对值。
10	double floor(double);该函数返回一个小于或等于传入参数的最大整数。
11	void srand(unsigned seed); 随机数发生器的初始化函数
12	int rand();生成随机数（使用前必须先调用srand()）

字符串操作

#include <cstring>

序号	函数 & 目的
1	strcpy(s1, s2);复制字符串 s2 到字符串 s1。
2	strcat(s1, s2);连接字符串 s2 到字符串 s1 的末尾。
3	strlen(s1);返回字符串 s1 的长度。
4	strcmp(s1, s2);如果 s1 和 s2 是相同的，则返回 0；如果 s1<s2 则返回值小于 0；如果 s1>s2 则返回值大于 0。
5	strchr(s1, ch);返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
6	strstr(s1, s2);返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。