C++ NUM4

 
c++数字：
c++内置丰富的数学函数，引用数学头文件<cmath>
double cos(double);余弦
double sin(double);正弦
double tan(double);正切
double log(double);对数
double pow(double x,double y);  x的y次方
double hypot(double,double); 两个参数的平方总和的平方根
double sqrt(double); 参数的平方根
int abs(int); 整数的绝对值
double fabs(double);浮点数的绝对值
double floor(double); 小于或等于传入参数的最大整数

c++随机数：在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。
rand() 产生的随机数在每次运行的时候都是与上一次相同的。若要不同, 用函数 srand() 初始化它。可以利用 srand((unsigned int)(time(NULL)) 的方法，产生不同的随机数种子，因为每一次运行程序的时间是不同的。
如： time() 函数来获取系统时间的秒数
#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++数组：
type arrayName [ arraySize ]; 一维数组   double b[10];
所有的数组都是以 0 作为它们第一个元素的索引，也被称为基索引，数组的最后一个索引是数组的总大小减去 1。
数组元素可以通过数组名称加索引进行访问。元素的索引是放在方括号内，跟在数组名称的后边。如：double s=b[9];
 
setw()函数：用于设置字段的宽度
setw(n);  n代表宽度，用数字表示，setw()只对紧接着的输出产生作用
当后面紧跟着的输出字段长度小于 n 的时候，在该字段前面用空格补齐，当输出字段长度大于 n 时，全部整体输出。
如：
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    // 开头设置宽度为 4，后面的 runoob 字符长度大于 4，所以不起作用
    cout << setw(4) << "runoob" << endl;
    // 中间位置设置宽度为 4，后面的 runoob 字符长度大于 4，所以不起作用
    cout << "runoob" << setw(4) << "runoob" << endl;
    // 开头设置间距为 14，后面 runoob 字符数为6，前面补充 8 个空格
    cout << setw(14) << "runoob" << endl;
    // 中间位置设置间距为 14 ，后面 runoob 字符数为6，前面补充 8 个空格
    cout << "runoob" << setw(14) << "runoob" << endl;
    return 0;
}
输出：
runoob
runoobrunoob
        runoob
runoob        runoob 
 
setw()默认填充的内容为空格，setfill()配合使用设置其他字符填充
cout<<setfill('*')<<"run"<<endl;
********run

数组：
多维数组：type name[size1][size2]...[sizeN];  如：int threedim[5][10][4];
二维数组：声明一个 x 行 y 列的二维整型数组，type arrayName [ x ][ y ];
初始化： 
int a[3][4] = {  
 {0, 1, 2, 3} ,   /*  初始化索引号为 0 的行 */
 {4, 5, 6, 7} ,   /*  初始化索引号为 1 的行 */
 {8, 9, 10, 11}   /*  初始化索引号为 2 的行 */
};
或：int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

指向数组的指针：
数组名是指向数组中第一个元素的常量指针double runoobAarray[50];
runoobAarray 是一个指向 &runoobAarray[0] 的指针，即数组 runoobAarray 的第一个元素的地址
如：
double *p;
double runoobAarray[10];
p = runoobAarray;

*p、*(p+1)、*(p+2) 等来访问数组元素
*(runoobAarray + 4) 是一种访问 runoobAarray[4] 数据的合法方式。
例如：
#include <iostream>
using namspace std;
int main(){
    double run[5]={1000.0,2.0,3.4,17.0,50.0};
    double *p;
    p=run;
    for(int i=0;i<5;i++){
        cout<<"*(p+"<<i<<"):";
        cout<<*(p+i)<<endl;
    }
    for(int i=0;i<5;i++){
        cout<<"(run+"<<i<<"):";
        cout<<*(run+i)<<endl;
    }
    return 0;
} 
p 是一个指向 double 型的指针，这意味着它可以存储一个 double 类型的变量。一旦我们有了 p 中的地址，*p 将给出存储在 p 中相应地址的值
 

传递数组给函数：通过指定不带索引的数组名来传递一个指向数组的指针。
传数组给一个函数，数组类型自动转换为指针类型，因而传的实际是地址。
方式一：
形式参数是一个指针
void myFunction(int *param)
{
.
.
.
}
方式二：
形式参数是一个已定义大小的数组：
void myFunction(int param[10])
{
.
.
.
}
方式三：
形式参数是一个未定义大小的数组：
void myFunction(int param[])
{
.
.
.
}

从函数返回数组：
可以通过指定不带索引的数组名来返回一个指向数组的指针。
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();
    cout << r[i] << endl;
  }
 
  return r;
}
// 要调用上面定义函数的主函数
int main ()
{
   // 一个指向整数的指针
   int *p;
 
   p = getRandom();
   for ( int i = 0; i < 10; i++ )
   {
       cout << "*(p + " << i << ") : ";
       cout << *(p + i) << endl;
   }
 
   return 0;
}
定义局部变量为 static 变量

c++字符串：
字符串实际上是使用 null 字符 \0 终止的一维字符数组。
char site[7] = {'R', 'U', 'N', 'O', 'O', 'B', '\0'};
或： char site[] = "RUNOOB";

strcpy（s1,s2);复制字符串 s2 到字符串 s1
strcat(s1,s2); 连接字符串 s2 到字符串 s1 的末尾。连接字符串也可以用 + 号
strlen(s1);返回字符串s1长度
strchr(s1,ch); 返回一个指针，指向字符串 s1 中字符 ch 的第一次出现的位置。
strstr(s1,s2);返回一个指针，指向字符串 s1 中字符串 s2 的第一次出现的位置。
str3.size(); str3总长度

C++指针：
每一个变量都有一个内存位置，每一个内存位置都定义了可使用连字号（&）运算符访问的地址，它表示了在内存中的一个地址。
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。
int    *ip;    /* 一个整型的指针 */
double *dp;    /* 一个 double 型的指针 */
float  *fp;    /* 一个浮点型的指针 */
char   *ch;    /* 一个字符型的指针 */
使用一元运算符 * 来返回位于操作数所指定地址的变量的值
例如：
#include <iostream>
using namespace std;
int main ()
{
   int  var = 20;   // 实际变量的声明
   int  *ip;        // 指针变量的声明
   ip = &var;       // 在指针变量中存储 var 的地址
   cout << "Value of var variable: ";
   cout << var << endl;
   // 输出在指针变量中存储的地址
   cout << "Address stored in ip variable: ";
   cout << ip << endl;
   // 访问指针中地址的值
   cout << "Value of *ip variable: ";
   cout << *ip << endl;
   return 0;
} 

结果：
Value of var variable: 20
Address stored in ip variable: 0xbfc601ac
Value of *ip variable: 20

Null指针：
赋为 NULL 值的指针被称为空指针。
int *p=NULL;

指针的算术运算： ++、--、+、-
递增减一个指针：
#include <iostream>
using namespace std;
const int MAX = 3;
int main ()
{
   int  var[MAX] = {10, 100, 200};
   int  *ptr;
   // 指针中的数组地址
   ptr = var;
   for (int i = 0; i < MAX; i++)
   {
      cout << "Address of var[" << i << "] = ";
      cout << ptr << endl;
 
      cout << "Value of var[" << i << "] = ";
      cout << *ptr << endl;
      // 移动到下一个位置
      ptr++;  //pte--;   而不能写var++； 
   }
   return 0;
} 
结果：
Address of var[0] = 0xbfa088b0
Value of var[0] = 10
Address of var[1] = 0xbfa088b4
Value of var[1] = 100
Address of var[2] = 0xbfa088b8
Value of var[2] = 200
指针可以用关系运算符进行比较，如 ==、< 和 >。如果 p1 和 p2 指向两个相关的变量，比如同一个数组中的不同元素，则可对 p1 和 p2 进行大小比较。

一个指向数组开头的指针，可以通过使用指针的算术运算或数组索引来访问数组。
由于一个数组名对应一个指针常量，只要不改变数组的值，仍然可以用指针形式的表达式。
把 var[2] 赋值为 500： *(var + 2) = 500;

一个指向整数的指针数组的声明：int *ptr[MAX];
一个指向字符的指针数组来存储一个字符串列表，如： 
#include <iostream>
using namespace std;
const int MAX = 4;
int main ()
{
 const char *names[MAX] = {
                   "Zara Ali",
                   "Hina Ali",
                   "Nuha Ali",
                   "Sara Ali",
   };
   for (int i = 0; i < MAX; i++)
   {
      cout << "Value of names[" << i << "] = ";
      cout << names[i] << endl;
   }
   return 0;
}

指向指针的指针：
指向指针的指针是一种多级间接寻址的形式，或者说是一个指针链。
指针的指针就是将指针的地址存放在另一个指针里面。
通常，一个指针包含一个变量的地址。当我们定义一个指向指针的指针时，第一个指针包含了第二个指针的地址，第二个指针指向包含实际值的位置。
一个指向指针的指针变量必须如下声明，即在变量名前放置两个星号。  int **var;
如：
#include <iostream>
using namespace std;
int main ()
{
    int  var;
    int  *ptr;
    int  **pptr;
    var = 3000;
    // 获取 var 的地址
    ptr = &var;
    // 使用运算符 & 获取 ptr 的地址
    pptr = &ptr;
    // 使用 pptr 获取值
    cout << "var 值为 :" << var << endl;
    cout << "*ptr 值为:" << *ptr << endl;
    cout << "**pptr 值为:" << **pptr << endl;
    return 0;
} 
结果：
var 值为 :3000
*ptr 值为:3000
**pptr 值为:3000

注意注意！！！在写函数时应习惯性的先声明函数，然后在定义函数 
传递指针给函数
能接受指针作为参数的函数，也能接受数组作为参数
如：
#include <iostream>
using namespace std;
// 函数声明
double getAverage(int *arr, int size);
int main ()
{
   // 带有 5 个元素的整型数组
   int balance[5] = {1000, 2, 3, 17, 50};
   double avg;
   // 传递一个指向数组的指针作为参数
   avg = getAverage( balance, 5 ) ;
   // 输出返回值
   cout << "Average value is: " << avg << endl; 
   return 0;
}
 
double getAverage(int *arr, int size)
{
  int    i, sum = 0;       
  double avg;          
  for (i = 0; i < size; ++i)
  {
    sum += arr[i];
   }
  avg = double(sum) / size;
  return avg;
}

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

引用:引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。
区别引用与指针：
 不存在空引用。引用必须连接到一块合法的内存。
一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
引用必须在创建时被初始化。指针可以在任何时间被初始化。
int i =17;
int &r=i;
&引用  
把引用作为参数，如：
#include <iostream>
using namespace std;
// 函数声明
void swap(int& x, int& y);
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   cout << "交换前，a 的值：" << a << endl;
   cout << "交换前，b 的值：" << b << endl;
   /* 调用函数来交换值 */
   swap(a, b);
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;
   return 0;
}
 
// 函数定义
void swap(int& x, int& y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
   return;
}

把引用作为返回值：当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。
当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。

日期&时间：
引用 <ctime> 头文件
有四个与时间相关的类型：clock_t、time_t、size_t 和 tm
类型 clock_t、size_t 和 time_t 能够把系统时间和日期表示为某种整数。
struct tm {
  int tm_sec;   // 秒，正常范围从 0 到 59，但允许至 61
  int tm_min;   // 分，范围从 0 到 59
  int tm_hour;  // 小时，范围从 0 到 23
  int tm_mday;  // 一月中的第几天，范围从 1 到 31
  int tm_mon;   // 月，范围从 0 到 11
  int tm_year;  // 自 1900 年起的年数
  int tm_wday;  // 一周中的第几天，范围从 0 到 6，从星期日算起
  int tm_yday;  // 一年中的第几天，范围从 0 到 365，从 1 月 1 日算起
  int tm_isdst; // 夏令时
};

函数：
time_t time(time_t *seconds)  该函数返回系统的当前日历时间
char *ctime(const time_t *time);该返回一个表示当地时间的字符串指针，字符串形式 day month year hours:minutes:seconds year\n\0。
struct tm *localtime(const time_t *time);该函数返回一个指向表示本地时间的 tm 结构的指针。
clock_t clock(void);该函数返回程序执行起（一般为程序的开头），处理器时钟所使用的时间。如果时间不可用，则返回 -1。
char * asctime ( const struct tm * time );该函数返回一个指向字符串的指针，字符串包含了 time 所指向结构中存储的信息，返回形式为：day month date hours:minutes:seconds year\n\0。
struct tm *gmtime(const time_t *time);该函数返回一个指向 time 的指针，time 为 tm 结构，用协调世界时（UTC）也被称为格林尼治标准时间（GMT）表示。
time_t mktime(struct tm *time);该函数返回日历时间，相当于 time 所指向结构中存储的时间。
double difftime ( time_t time2, time_t time1 );该函数返回 time1 和 time2 之间相差的秒数。
size_t strftime();该函数可用于格式化日期和时间为指定的格式。

获取日期和时间：
#include <iostream>
#include <ctime>
using namespace std;
int main( )
{
   // 基于当前系统的当前日期/时间
   time_t now = time(0);
   // 把 now 转换为字符串形式
   char* dt = ctime(&now);
   cout << "本地日期和时间：" << dt << endl;
   // 把 now 转换为 tm 结构
   tm *gmtm = gmtime(&now);
   dt = asctime(gmtm);
   cout << "UTC 日期和时间："<< dt << endl;
}

使用箭头 -> 运算符来访问结构成员
#include <iostream>
#include <ctime>
using namespace std;
int main( )
{
   // 基于当前系统的当前日期/时间
   time_t now = time(0);
   cout << "1970 到目前经过秒数:" << now << endl;
   tm *ltm = localtime(&now);
   // 输出 tm 结构的各个组成部分
   cout << "年: "<< 1900 + ltm->tm_year << endl;
   cout << "月: "<< 1 + ltm->tm_mon<< endl;
   cout << "日: "<<  ltm->tm_mday << endl;
   cout << "时间: "<< ltm->tm_hour << ":";
   cout << ltm->tm_min << ":";
   cout << ltm->tm_sec << endl;
}

基本的输入输出
<iostream>   <iomanip>   <fstream>
流插入运算符 << 在一个语句中可以多次使用，如上面实例中所示，endl 用于在行末添加一个换行符。

标准输入流：cin    cin 是与流提取运算符 >> 结合使用的 
 cin >> name;  输入名称
流提取运算符 >> 在一个语句中可以多次使用
cin >> name >> age;

标准错误流：cerr 也是与流插入运算符 << 结合使用的
标准日志流：clog 也是与流插入运算符 << 结合使用的

注意：
#include <iostream>
#include <iomanip>
using namespace std;
int main()
{
    cout<<setiosflags(ios::left|ios::showpoint);  // 设左对齐，以一般实数方式显示
    cout.precision(5);       // 设置除小数点外有五位有效数字 
    cout<<123.456789<<endl;
    cout.width(10);          // 设置显示域宽10 
    cout.fill('*');          // 在显示区域空白处用*填充
    cout<<resetiosflags(ios::left);  // 清除状态左对齐
    cout<<setiosflags(ios::right);   // 设置右对齐
    cout<<123.456789<<endl;
    cout<<setiosflags(ios::left|ios::fixed);    // 设左对齐，以固定小数位显示
    cout.precision(3);    // 设置实数显示三位小数
    cout<<999.123456<<endl; 
    cout<<resetiosflags(ios::left|ios::fixed);  //清除状态左对齐和定点格式
    cout<<setiosflags(ios::left|ios::scientific);    //设置左对齐，以科学技术法显示 
    cout.precision(3);   //设置保留三位小数
    cout<<123.45678<<endl;
    return 0; 
}
cout.setf 跟 setiosflags 一样，cout.precision 跟 setprecision 一样，cout.unsetf 跟 resetiosflags 一样。
cin.get() 是可以忽略掉一个字符的

cin>>a;cin.get();
cin>>b;cin.get();
cin>>c;
输入 1, 2, 3 或者 1a2b3 

数据结构:https://www.runoob.com/cplusplus/cpp-data-structures.html
定义结构，使用struct语句
struct type_name {
member_type1 member_name1;
member_type2 member_name2;
member_type3 member_name3;
.
.
} object_names;

例如：
struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
} book;

访问结构成员：成员访问运算符（.）
结构作为函数参数
指向结构的指针： struct Books *struct_pointer;
struct_pointer = &Book1;
struct_pointer->title;
 
typedef关键字：
typedef struct Books
{
   char  title[50];
   char  author[50];
   char  subject[100];
   int   book_id;
}Books;
直接使用 Books 来定义 Books 类型的变量，而不需要使用 struct 关键字

使用 typedef 关键字来定义非结构类型
typedef long int *pint32;
pint32 x, y, z;