STL4-类型转换

                                        

                                         

                                         

#include<iostream>
using namespace std;class Building{};
class Animal{};
class Cat :public Animal {};  //Cat是Animal的子类//static_cast
//用于内置的数据类型及具有继承关系的指针或者引用
void test01()
{int a = 97;//static_cast<要转换的类型>(转换的数据)char c = static_cast<char>(a);cout << c << endl;//基础数据类型指针 错误/*int* p = NULL;char* sp = static_cast<char*>(p);*///对象指针 错误/*Building* building = NULL;Animal* animal = static_cast<Animal*>(building);*///具有继承关系的对象指针//父类指针转换为子类指针Animal* animal = NULL;Cat* cat = static_cast<Cat*>(animal);//子类指针转换为父类指针Cat* soncat = NULL;Animal* animal_father = static_cast<Animal*>(soncat);//父类引用zhuan子类引用Animal aniobj;Animal& aniref = aniobj;Cat& cat2 = static_cast<Cat&>(aniref);//子类引用转父类引用Cat catobj;Cat& catref = catobj;Animal& anifather2 = static_cast<Animal&>(catref);
}//dynamic_cast
//只能转换具有继承关系的指针或者引用，在转换前会进行对象类型的检测(安全转换)
//只能由子类型转换为父类型
void test02()
{//基础数据类型  错误//int a = 97;/*char c = dynamic_cast<char>(a);*///基础数据类型指针 错误/*int* p = NULL;char* sp = dynamic_cast<char*>(p);*///非继承关系的指针 错误/*Animal* animal = NULL;Building* building = dynamic_cast<Building*>(animal);*///具有继承关系的指针//父类指针转为子类指针  错误//子类转换为父类是安全（从大到小） 父类转换为子类是不安全的（从小到大）/*Animal* ani = NULL;  Cat * cat = dynamic_cast<Cat*>(ani);  原因在于dynamic_cast自动做类型安全检测*///子类指针转换为父类指针Cat* cat1 = NULL;Animal* ani = dynamic_cast<Animal*>(cat1);
}//const_cast  取消或者添加变量的const属性后赋值给新值
//针对指针，引用，对象指针
void test03()
{//基础数据类型int a = 10;const int &b = a;  //引用 别名//b=20; //错误  int& c = const_cast<int&>(b);c = 20;cout << "a:" << a << endl;cout << "b:" << b << endl;cout << "c:" << c << endl;//指针const int *p = NULL;int* p2=const_cast<int*>(p);int* p3 = NULL;const int* p4 = const_cast<const int*>(p3);
}//reinterpret_cast  强制类型转换 
//只转换指针
//任何类型指针都可以转换为其他类型指针(包括函数指针)
typedef void(*FUNC1)(int, int);//申明一个指针变量FUNC1,指向int(*)(int, int)
void add(int a, int b)
{cout << a + b << endl;
}
typedef int(*FUNC2)(int, char*);void test04()
{//1、无关的指针类型都可以进行转换Building* building = NULL;Animal* ani = reinterpret_cast<Animal*>(building);//2.函数指针转换FUNC1 func1=add;//若不用typedef，可以直接func = add （此时，func就是变量，而非变量别名）func1(1, 2);FUNC2 func2 = reinterpret_cast<FUNC2>(func1);
}int main(void)
{test01();test02();test03();test04();system("pause");return 0;
}

运行结果：

二、关于typedef void(*FUNC1)(int, int)的理解

#include "iostream"

using namespace std;

int add(int a,int b){
return (a+b);
}

typedef int (* func)(int ,int ) ;

void main(){
func f = add;
int n = f(1,2);
cout << n << endl;
}

在这里的意思是定义一种指针类型func，它是一种指向函数int (int,int)的指针，也就是说func表示的是这种类型的函数的地址，因为：

函数名不是其类型的一部分，函数的类型只由它的返回值和参数表决定.指向add()的指针必须指向与add()相同类型的函数带有相同的返回类型和相同的参数表   。

int (* func)(int ,int )和int* func(int ,int )是不同的，后者说明的是返回一个int类型的指针，所以括号是必须加的

　typedef为C语言的关键字，作用是为一种数据类型定义一个新名字。这里的数据类型包括内部数据类型（int,char等）和自定义的数据类型（struct等）。

在编程中使用typedef目的一般有两个

        1、一个是给变量一个易记且意义明确的新名字

        2、另一个是简化一些比较复杂的类型声明。

用typedef只是对已经存在的类型增加一个类型名，而没有创造一个新的类型。只是增加了一个新名字，可以用该名字定义变量

二．用法

（1）用typedef声明一个新类型名来代替已有的类型名。如：

typedef int Status  //指定标识符Status代表int类型
typedef double DATE  //指定标识符DATE代表double类型

这样下面代码等价：

int i; double j;
Status i;DATE j;

（2）用typedef对数组类型起新名：

typedef int NUM[100];//声明NUM为整数数组类型，可以包含100个元素
NUM n;//定义n为包含100个整数元素的数组，n就是数组名

（3）对一个结构体类型声明一个新名字：

typedef struct  //在struct之前用了关键字typedef，表示是声明新类型名
{int month;int day;int year;  
} TIME; //TIME是新类型名，但不是新类型，也不是结构体变量名

 新声明的新类型名TIME代表上面指定的一个结构体类型，这样就可以用TIME定义该结构体变量，如：

TIME birthday;
TIME *P //p是指向该结构体类型数据的指针

 

在typdef可以定义更加复杂的类型，这种情况遇到的不是很多，有时候多层的嵌套会将代码演变的异常复杂，可读性变差。虽然不推荐这么写，但是对于他人写的代码要能理解。关于复杂定义的方式可以阅读参考文献6中的描述：

理解复杂声明可用的“右左法则”：从变量名看起，先往右，再往左，碰到一个圆括号就调转阅读的方向；括号内分析完就跳出括号，还是按先右后左的顺序，如此循环，直到整个声明分析完。举例：
int (*func)(int *p)
首先找到变量名func，外面有一对圆括号，而且左边是一个*号，这说明func是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*func)是一个函数，所以func是一个指向这类函数的指针，即函数指针，这类函数具有int*类型的形参，返回值类型是int。
int (*func[5])(int *)
func右边是一个[]运算符，说明func是具有5个元素的数组；func的左边有一个*，说明func的元素是指针（注意这里的*不是修饰func，而是修饰func[5]的，原因是[]运算符优先级比*高，func先跟[]结合）。跳出这个括号，看右边，又遇到圆括号，说明func数组的元素是函数类型的指针，它指向的函数具有int*类型的形参，返回值类型为int。
 

 2. 隐藏技能

typedef 定义的新类型, 使用时可以省略括号.

 


typedef int NUM;
NUM a = 10; // 也可写成`NUM(a) = 10;
NUM(b) = 12; // 也可写成`NUM b = 12;

整形： 

typedef int x; // 定义了一个名为x的int类型

结构体：

typedef struct { char c; } s; // 定义名为s的struct类型

指针

typedef int *p; //定义了一个名为p的指针类型, 它指向int (中文描述指针好累)


接下来是高级的(注意标识符不一定在最后):
数组

typedef int A[];  // 定义一个名为A的ints数组的类型

函数：


typedef int f(); // 定义一个名为f, 参数为空, 返回值为int的函数类型
typedef int g(int); // 定义一个名为g, 含一个int参数, 返回值为int行的函数类型

typedef int P();
static P(Q);

应该就比较好理解了, P是一个新定义的function类型, 它返回值为int, 无参数
根据我的第2点说明, P(Q); 实际上等价于P Q, 声明Q是一个返回值为int, 无参数的函数.

 

这玩意有什么用呢?
我们都知道C++语言里, 函数都是先声明后使用的(除非在使用之前定义), 看以下例子:

#include <iostream>
#include <stdio.h>
#include <string>
typedef int P(); // 简单的
typedef void Q(int *p, const std::string& s1, const std::string& s2, size_t size, bool is_true); // 复杂的
class X {
public:P(eat_shit); // 等价于声明`int eat_shit();`Q(bullshit); // 等价于声明`void bullshit(int *p, const string& s1, const string& s2, size_t size, bool is_true);`
};int main() {X *xx;printf("shit ret: %d\n", xx->eat_shit());int a[] = {1, 3, 4, 5, 7};xx->bullshit(a, "foo", "bar", sizeof(a)/sizeof(int), true);
}
int X::eat_shit() {return 888;
}void X::bullshit(int *p, const std::string& s1, const std::string& s2, size_t size, bool is_true) {std::cout << "s1: " << s1 << ", s2: " << s2 << ", size: " << size << std::endl;printf("elems:\n");for(int i = 0; i < size; i++) {printf("%d %s",  *p++, (i == size-1) ? "" : ",");}printf("\n");
}

在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义，例如：

        (1)  void * (* (*fp1) (int)) [10];

        (2)  float (* (*fp2) (int, int, float)) (int);

        (3)  typedef double (* (* (*fp3) ()) [10]) ();

               fp3 a;

        (4)  int (* (*fp4()) [10]) ();

        刚看到这些声明或者定义时，一些初学者甚至有一定经验的工程师都有可能头皮发毛，基于大惑不解。如果缺乏经验和方法来对这些内容进行理解，势必会让我们浪费大量的时间。

        我尝试对这些内容进行疏理和总结，为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义，我觉得首先不能着急，应该由浅而深，逐步突破。下面先看一些简单的定义：

        1. 定义一个整型数

            int a;

        2. 定义一个指向整型数的指针

            int *p;

        3. 定义一个指向指针的指针，它指向的指针指向一个整型数

            int **pp;

        到这一步我想大多数人都还好理解，我们可以用一些简单的代码把这三条给串起来：

在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义，例如：

        (1)  void * (* (*fp1) (int)) [10];

        (2)  float (* (*fp2) (int, int, float)) (int);

        (3)  typedef double (* (* (*fp3) ()) [10]) ();

               fp3 a;

        (4)  int (* (*fp4()) [10]) ();

        刚看到这些声明或者定义时，一些初学者甚至有一定经验的工程师都有可能头皮发毛，基于大惑不解。如果缺乏经验和方法来对这些内容进行理解，势必会让我们浪费大量的时间。

        我尝试对这些内容进行疏理和总结，为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义，我觉得首先不能着急，应该由浅而深，逐步突破。下面先看一些简单的定义：

        1. 定义一个整型数

            int a;

        2. 定义一个指向整型数的指针

            int *p;

        3. 定义一个指向指针的指针，它指向的指针指向一个整型数

            int **pp;

        到这一步我想大多数人都还好理解，我们可以用一些简单的代码把这三条给串起来：

在阅读Linux的内核代码是经常会遇到一些复杂的声明和定义，例如：

        (1)  void * (* (*fp1) (int)) [10];

        (2)  float (* (*fp2) (int, int, float)) (int);

        (3)  typedef double (* (* (*fp3) ()) [10]) ();

               fp3 a;

        (4)  int (* (*fp4()) [10]) ();

        刚看到这些声明或者定义时，一些初学者甚至有一定经验的工程师都有可能头皮发毛，基于大惑不解。如果缺乏经验和方法来对这些内容进行理解，势必会让我们浪费大量的时间。

        我尝试对这些内容进行疏理和总结，为自己和有同样困惑的同学答疑解惑。要理解这些复杂的声明和定义，我觉得首先不能着急，应该由浅而深，逐步突破。下面先看一些简单的定义：

  1. 定义一个整型数

            int a;

   2. 定义一个指向整型数的指针

            int *p;

   3. 定义一个指向指针的指针，它指向的指针指向一个整型数

            int **pp;

        到这一步我想大多数人都还好理解，我们可以用一些简单的代码把这三条给串起来：


int a;
int *p;
int **pp;
p = &a;   // p指向整数a所在的地址
pp = &p;  // pp指向指针p

4. 定义一个包含10个整型数的数组

            int arr[10];

 5. 定义一个指向包含10个整型数数组的指针

            int (*pArr) [10];

        用几行代码将4、5两个定义串起来：


int arr[10];
int (*pArr) [10];pArr = &arr;

6. 定义一个指向函数的指针，被指向的函数有一个整型参数并返回整型值

 

             int (*pfunc) (int);

 7. 定义一个包含10个指针的数组，其中包含的指针指向函数，这些函数有一个整型参数并返回整型值

             int (*arr[10]) (int);

 

        用几行代码将6、7两个定义串起来：


int (*pfunc) (int);
int (*arr[10]) (int);arr[0] = pfunc;

到这一步，似乎就不是那么好理解了。现在需要请出用于理解复杂定义的“右左法则”：

 

        从变量名看起，先往右，再往左，碰到圆括号就调转阅读的方向；括号内分析完就跳出括号，还是先右后左的顺序。如此循环，直到分析完整个定义。

        让我们用这个方法来分析上面的第6条定义：int (*pfunc) (int);

        找到变量名pfunc，先往右是圆括号，调转方向，左边是一个*号，这说明pfunc是一个指针；然后跳出这个圆括号，先看右边，又遇到圆括号，这说明(*pfunc)是一个函数，所以pfunc是一个指向这类函数的指针，即函数指针，这类函数具有一个int类型的参数，返回值类型是int。

        接着分析第7条定义：int (*arr[10]) (int);

        找到变量名arr，先往右是[]运算符，说明arr是一个数组；再往左是一个*号，说明arr数组的元素是指针（注意：这里的*修饰的不是arr，而是arr[10]。原因是[]运算符的优先级比*要高，arr先与[]结合。）；跳出圆括号，先往右又遇到圆括号，说明arr数组的元素是指向函数的指针，它指向的函数有一个int类型的参数，返回值类型是int。

        分析完这两个定义，相信多数人心里面应该有点谱了。可应该还有人会问：怎么判断定义的是函数指针（定义6），还是数组指针（定义5），或是数组（定义7）？可以抽象出几个模式：

  • type (*var)(...); // 变量名var与*结合，被圆括号括起来，右边是参数列表。表明这是函数指针
  • type (*var)[];    //变量名var与*结合，被圆括号括起来，右边是[]运算符。表示这是数组指针
  • type (*var[])...;     // 变量名var先与[]结合，说明这是一个数组（至于数组包含的是什么，由旁边的修饰决定）   

        至此，我们应该有能力分析文章开始列出来了几条声明和定义：

        (1)  void * (* (*fp1) (int)) [10];

        找到变量名fp1，往右看是圆括号，调转方向往左看到*号，说明fp1是一个指针；跳出内层圆括号，往右看是参数列表，说明fp1是一个函数指针，接着往左看是*号，说明指向的函数返回值是指针；再跳出外层圆括号，往右看是[]运算符，说明函数返回的是一个数组指针，往左看是void *，说明数组包含的类型是void *。简言之，fp1是一个指向函数的指针，该函数接受一个整型参数并返回一个指向含有10个void指针数组的指针。

        (2) float (* (*fp2) (int, int, float)) (int);

        找到变量名fp2，往右看是圆括号，调转方向往左看到*号，说明fp2是一个指针；跳出内层圆括号，往右看是参数列表，说明fp2是一个函数指针，接着往左看是*号，说明指向的函数返回值是指针；再跳出外层圆括号，往右看还是参数列表，说明返回的指针是一个函数指针，该函数有一个int类型的参数，返回值类型是float。简言之，fp2是一个指向函数的指针，该函数接受三个参数(int, int和float)，且返回一个指向函数的指针，该函数接受一个整型参数并返回一个float。

 

        (3)  typedef double (* (* (*fp3) ()) [10]) ();

               fp3 a;

        如果创建许多复杂的定义，可以使用typedef。这一条显示typedef是如何缩短复杂的定义的。

        跟前面一样，先找到变量名fp3（这里fp3其实是新类型名），往右看是圆括号，调转方向往左是*，说明fp3是一个指针；跳出圆括号，往右看是空参数列表，说明fp3是一个函数指针，接着往左是*号，说明该函数的返回值是一个指针；跳出第二层圆括号，往右是[]运算符，说明函数的返回值是一个数组指针，接着往左是*号，说明数组中包含的是指针；跳出第三层圆括号，往右是参数列表，说明数组中包含的是函数指针，这些函数没有参数，返回值类型是double。简言之，fp3是一个指向函数的指针，该函数无参数，且返回一个含有10个指向函数指针的数组的指针，这些函数不接受参数且返回double值。

        这二行接着说明：a是fp3类型中的一个。

        (4)  int (* (*fp4()) [10]) ();

        这里fp4不是变量定义，而是一个函数声明。

        找到变量名fp4，往右是一个无参参数列表，说明fp4是一个函数，接着往左是*号，说明函数返回值是一个指针；跳出里层圆括号，往右是[]运算符，说明fp4的函数返回值是一个指向数组的指针，往左是*号，说明数组中包含的元素是指针；跳出外层圆括号，往右是一个无参参数列表，说明数组中包含的元素是函数指针，这些函数没有参数，返回值的类型是int。简言之，fp4是一个返回指针的函数，该指针指向含有10个函数指针的数组，这些函数不接受参数且返回整型值。

  • 用typedef简化复杂的声明和定义

        以上我们已经看到了不少复杂的声明和定义，这里再举一个例子：

        int *(*a[10]) (int, char*);

        用前面的“右左法则”，我们可以很快弄清楚：a是一个包含10个函数指针的数组，这些函数的参数列表是(int, char*)，返回值类型是int*。理解已经不成问题，这里的关键是如果要定义相同类型的变量b，都得重复书写：

        int *(*b[10]) (int, char*);

        这里有没有方便的办法避免这样没有价值的重复？答案就是用typedef来简化复杂的声明和定义。

        typedef可以给现有的类型起个别名。这里用typedef给以上a、b的类型起个别名： 

typedef int *(*A[10]) (int, char*); // 在之前定义的前面加入typedef，然后将变量名a替换成类型名A

现在要再定义相同类型的变量c，只需要：

        A c;

 

        再看一例：

        void (*b[10]) (void (*)());

        先替换右边括号里面的参数，将void (*)()的类型起个别名pParam：       

typedef void (*pParam) ();

再替换左边的变量b，为b的类型起个别名B：


typedef void (*B) (pParam);

原声明的简化版：

B b[10]; 
#include<stdio.h>
int inc(int a)
{return(++a);
}int multi(int*a, int*b, int*c)
{return(*c = *a**b);
}typedef int(FUNC1)(int); //申明一个指针变量FUNC1,指向int(int)
typedef int(FUNC2)(int*, int*, int*);void show(FUNC2 fun, int arg1, int *arg2)
{//fun 为指向函数int multi(int*a,int*b,int*c)的指针//arg1 = 10，arg2 =&a;FUNC1 *p = &inc;         //p为指向函数inc的指针int temp = p(arg1);      //等价于 temp = inc(arg1) = inc(10) = 11fun(&temp, &arg1, arg2);//运行fun（）函数后，*arg2 = temp * arg1 = 11 * 10 = 110printf("%d\n", *arg2);
}
int main()
{int a;show(multi, 10, &a);return 0;
}

结果为110

参考自https://blog.csdn.net/hai008007/article/details/80651886

https://blog.csdn.net/baoendemao/article/details/41209697

 

 

 

 

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/567970.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

线程池写入mysql_用多线程写入数据库的问题(150分)

线程池写入mysql_用多线程写入数据库的问题(150分)

把 一少的程序稍加修改就可以多个线程处理一个文件了unit Unit1;interfaceusesWindows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs, StdCtrls;typeTForm1 class(TForm)Button1: TButton;procedure FormCreate(Sender: TObject);procedure Bu…
阅读更多...
java对象排序_Java™ 教程（对象排序）

java对象排序_Java™ 教程（对象排序）

对象排序List l可以如下排序。Collections.sort(l);如果List包含String元素&#xff0c;它将按字母顺序排序&#xff0c;如果它由Date元素组成&#xff0c;它将按时间顺序排序&#xff0c;这是怎么发生的&#xff1f;String和Date都实现了Comparable接口&#xff0c;Comparable…
阅读更多...
python argparse模块

python argparse模块

argparse模块 argparse是python用于解析命令行参数和选项的标准模块&#xff0c;用于代替已经过时的optparse模块 使用步骤 import argparse # 1 导入模块&#xff0c;这个没什么说的 parser argparse.ArgumentParser() # 2 实例化一个对象&#xff0c;默认参数一堆&#…
阅读更多...
java解析yml文件_如何基于JAVA读取yml配置文件指定key内容

java解析yml文件_如何基于JAVA读取yml配置文件指定key内容

这篇文章主要介绍了如何基于JAVA读取yml配置文件指定key内容,文中通过示例代码介绍的非常详细&#xff0c;对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下先引入需要的依赖org.yamlsnakeyaml1.23读取YML文件工具类的代码import org.apache.commons.lang3.St…
阅读更多...
STL5-异常

STL5-异常

异常可以跨函数 异常必须处理 1、 #include<iostream> using namespace std; //c异常机制 跨函数 //c异常必须处理 不能留&#xff0c;否则报错 int divided(int x, int y) {if (y 0)throw y; //抛异常return (x / y); } void test01() {int x 10, y 0;//试着去捕获…
阅读更多...
java 并发组件_Java 并发计数组件Striped64详解

java 并发组件_Java 并发计数组件Striped64详解

作者&#xff1a; 一字马胡转载标志 【2017-11-03】更新日志日期更新内容备注2017-11-03添加转载标志持续更新Java Striped64Striped64是在java8中添加用来支持累加器的并发组件&#xff0c;它可以在并发环境下使用来做某种计数&#xff0c;Striped64的设计思路是在竞争激烈的时…
阅读更多...
ubuntu的MySQL远程数据库连接问题查找

ubuntu的MySQL远程数据库连接问题查找

1、开放端口3306 2、添加权限 3、服务器本身没有在安全组规则中开放权限 添加安全组规则后重试。
阅读更多...
java中集合怎么定义_Java集合系列(一)：集合的定义及分类

java中集合怎么定义_Java集合系列(一)：集合的定义及分类

1. 集合的定义什么是集合呢&#xff1f;定义&#xff1a;集合是一个存放对象的引用的容器。在Java中&#xff0c;集合位于java.util包下。2. 集合和数组的区别(面试常问)提到容器&#xff0c;就会想起数组&#xff0c;那么集合和数组的区别是什么呢&#xff1f;(这里是重点&…
阅读更多...
STL6-输入输出流

STL6-输入输出流

cout 是 console output 缩写 程序 和键盘 之间有一个输入缓冲区 程序 和 显示器 之间有一个输出缓冲区 #include<iostream> #include<windows.h> #include<iomanip> using namespace std; #if 0 cout << "dd"; //全局流对象&#xff0c;默…
阅读更多...
azul java_Java版本更新重大提醒 - Azul

azul java_Java版本更新重大提醒 - Azul

2019年1月对于Java开发人员和用户都特别重要。原因是Oracle JDK 8发布了更新202&#xff0c;这是Oracle的JDK 8的最终公开更新(针对商业用户)。用户现在需要仔细考虑将来如何更新升级Java版本了。对于非商业桌面用户&#xff0c;将继续通过现有Java Update机制提供对Oracle Jav…
阅读更多...
java 自定义 钩子_Java添加关闭钩子里面的方法

java 自定义 钩子_Java添加关闭钩子里面的方法

在我的代码中&#xff0c;我使用CompletionService和ExecutorService来启动一堆Thread来执行某些任务(这可能需要很长时间) . 所以我有一个创建ExecutorService和CompletionService的方法&#xff0c;然后开始提交线程然后获取结果 . 我想添加一个关闭钩子&#xff0c;以便优雅…
阅读更多...
Ubuntu nginx+uwsgi部署Django项目

Ubuntu nginx+uwsgi部署Django项目

前提条件&#xff1a;首先项目使用一下命令启动成功后&#xff0c;输入公网ip后可以启动成功 python manage.py runserver 0.0.0.0:80 一、阿里云配置安全组 添加8000端口 二、安装配置uwsgi 1、确定django项目可以正常运行了&#xff0c;ctrlc停止项目&#xff0c;下面我们来…
阅读更多...
STL7-基础

STL7-基础

1、容器可以嵌套容器 2、容器分为序列式容器和关联式容器 序列式容器&#xff1a;容器的元素的位置是由进入容器时机和地点来决定 关联式容器&#xff1a;容器已经有规则&#xff0c;进入容器的元素的位置不是由进入容器时机和地点来决定 只与此容器的排列规则有关 3、迭代…
阅读更多...
java 0xaarrggbb 转换_RRGGBBAA或者RRGGBB转换成rgba()

java 0xaarrggbb 转换_RRGGBBAA或者RRGGBB转换成rgba()

//十六进制颜色值的正则表达式var reg /^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/;/*16进制颜色转为RGB格式*/var colorRgb function(color){if(color.length>7){var num color.slice(7,9).toUpperCase();var x opacityColor(num)color color.slice(0,7);}var sColor color…
阅读更多...
java 假设当前时间_Java中与日期和时间相关的类和方法

java 假设当前时间_Java中与日期和时间相关的类和方法

一、currentTimeMillis()方法System 类中的方法 currentTimeMillis() 方法可以返回从 GMT1970 年 1 月 1 日 00 : 00 : 00 开始到当前时刻的毫秒数。System.currentTimeMillis(); //返回值为long类型二、Date类1.构造方法(1)public Date (); 以当前系统时间创建一个Date对象&am…
阅读更多...
STL8-string容器

STL8-string容器

C 没有 string 类&#xff0c;但提供了直接对字符数组、字符串操作的函数 -> 如 str_len()等等 -> 需要包含 “string.h”#include<iostream> #include<string> using namespace std;//初始化 void test01() {string s1; //调用无参构造string s2(10, a);str…
阅读更多...
java 采集 cms_开源 java CMS - FreeCMS2.3 Web页面信息采集

java 采集 cms_开源 java CMS - FreeCMS2.3 Web页面信息采集

Web页面信息采集从FreeCMS 2.1开始支持通过简单配置即可抓取目标网页信息&#xff0c;支持增量式采集、关键字替换、定时采集&#xff0c;同一采集规则可采集多个页面(静态和动态)&#xff0c;可采集多种信息属性&#xff0c;可自动审核且静态化信息页面。采集规则管理从左侧管…
阅读更多...
Python中reshape函数参数-1的意思？

Python中reshape函数参数-1的意思？

import numpy as np c np.array([[1,2,3],[4,5,6]]) print(2行3列) print(c.reshape(2,3)) print(3行2列) print(c.reshape(3,2)) print(我也不知道几行&#xff0c;反正是一列) print(c.reshape(-1,1)) print(我也不知道几列&#xff0c;反正是一行) print(c.reshape(1,-1)) …
阅读更多...
java浮点数四舍五入_Java小程序练习--浮点数的四舍五入

java浮点数四舍五入_Java小程序练习--浮点数的四舍五入

今天学习到了关于浮点数的知识&#xff0c;而后便编写了一个小demo&#xff0c;实现浮点数的四舍五入&#xff0c;保留两位小数。具体实现思路如下:1.获取用户输入的数字&#xff0c;将其保存到double型变量中&#xff1b;2.因为要保存到小数点后的两位&#xff0c;将该数乘以1…
阅读更多...
STL9-vector容器

STL9-vector容器

vector容器 动态数组 可变数组 vector容器 单口容器 vector实现动态增长&#xff1a; 当插入新元素时&#xff0c;如果空间不足&#xff0c;那么vector会重新申请更大内存空间&#xff08;默认二倍&#xff09;&#xff0c;将原空间数据拷贝到新空间&#xff0c;释放旧空…
阅读更多...
最新文章

Copyright @ 2022~2023