文章目录
模板参数类型
整数模板参数
函数指针模板参数
指针及引用模板参数
成员函数指针模板参数
模板型模板参数


这是《深入实践C++模板编程》第三章“模板参数类型详解”的读书笔记。

模板参数类型
模板参数通常表示类型，表示类型的模板参数称为类型模板参数（type template parameter）;此外还有非类型模板参数（non-type template parameter），非类型模板参数包含以下四种类型：

整数及枚举类型
指针（对象指针或函数指针）
引用（对象引用或函数引用）
指向类对象成员函数的指针

模板的参数还可以是一个模板，叫做模板模板参数（template template parameter）。这些类型的模板参数都可以同时出现在模板参数列表中。
整数模板参数
非类型模板参数的作用，是为函数模板或类模板预定义一些常量。这些常量的值在编译期已知，所有模板实例中，都有相同的值。例如一个固定长度的数据类
#include <iostream>
#include <stdexcept>

template<typename T, unsigned size>
class array {
    T elems[size];
 public:
    T& operator[] (unsigned i) throw (std::out_of_range) {
        if (i >= size) {
            throw std::out_of_range("array access out of range.");
        }
        else return elems[i];
    }
};

int main(int argc, char* argv[]) {
    array<char, 20> array0;
    array<char, 10> array1;

    array0[10] = 'b';

    try {
        array1[10] = 'b';
    }
    catch (std::out_of_range& e) {
        std::cerr << "Access out of range." << std::endl;
    }
    return 0;
}

函数指针模板参数
函数指针通常用于实现回调。函数指针模板参数也可以用于实现回调，只不过普通函数指针的回调函数可以在运行期确定，函数指针作为模板参数时，要在编译期确定。
#include <iostream>

template<typename T, void (*f) (T &v)>
void foreach(T array[], unsigned size) {
    for (unsigned i = 0; i < size; ++i)
        f(array[i]);
}

template<typename T>
void inc(T &v) {
    ++v;
}

template<typename T>
void dec(T &v) {
    --v;
}

template<typename T>
void print(T& v) {
    std::cout<< ' ' << v;
}

int main(int argc, char* argv[]) {
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8};

    foreach<int, print<int>>(array, 8);
    std::cout << std::endl;

    foreach<int, inc<int>>(array, 8);
    foreach<int, print<int>>(array, 8);
    std::cout << std::endl;

    foreach<int, dec<int>>(array, 8);
    foreach<int, print<int>>(array, 8);
    std::cout << std::endl;
    return 0;
}

指针及引用模板参数
指针和引用作为模板参数时，相当于为函数或对象声明一个常量指针或引用。因为模板参数是在编译期确定的，所以只有全局变量/外部变量(extern修饰)/类的静态变量的指针或引用才可以作为模板参数。
#include <iostream>

template<int *p>
struct wrapper {
    int get() {
        return *p;
    }
    void set(int v) {
        *p = v;
    }
};

template<int &p>
struct wrapper2 {
    int get() {
        return p;
    }
    void set(int v) {
        p = v;
    }
};

int main(int argc, char* argv[]) {
	int global_variable = 0;
 	wrapper<&global_variable> gwrapper;
    gwrapper.set(1);
    std:: cout << gwrapper.get() << std::endl;

    wrapper2<global_variable> gwrapper2;
    gwrapper2.set(2);
    std::cout<< gwrapper2.get() << std::endl;

    return 0;
}

成员函数指针模板参数
成员函数指针作为函数模板参数时，和普通函数指针类型，只是声明方法看上去难理解。例如类some_class有多个函数，参数都为int，返回值也为int，那么指向这些成员函数的指针可以声明为
int (some_class:: *mfp)(int);

可以用typedef定义别名，精简一下
typedef int (some_class:* some_class_mfp)(int);
some_class_mfp mfp;

使用成员函数指针调用函数时，要用到操作符*.和->。这两个操作符优先级比较低，通常需要用括号括起来。例如：
some_class a;
std::cout << (a.*mfp)(0) << std::endl;

some_class *p(&a);
std::cout << (p->*mfp)(0) << std::endl;

下面示例为一个some_class类包含3个成员函数add_by,sub_by,mul_by，分别对成员变量value进行对应操作。
#include <iostream>
class some_value {
    int value;
 public:
    some_value(int _value): value(_value) {}
    int add_by(int op) { return value += op;}
    int sub_by(int op) { return value -= op;}
    int mul_by(int op) { return value *= op;}
};

int main(int argc, char* argv[]) {
    some_value v0(0);
    std::cout<< call<&some_value::add_by>(v0, 1) << std::endl;
    std::cout<< call<&some_value::sub_by>(v0, 2) << std::endl;
    std::cout<< call<&some_value::mul_by>(v0, 3) << std::endl;

    return 0;
}

需要注意的是，在取成员函数指针是，取地址符&不能省略。
模板型模板参数
模板型模板参数只是，模板的参数是另外一个模板。声明形式类似：
template<typename T, template<typename TT0, typename TT1> class A>
struct Foo {A<T, T> bar;};

上面声明中的第二个模板参数A是一个类模板。注意声明中要用到关键字class。只有类模板可以作为模板参数。
在函数指针模板参数的例子中，有
foreach<int, print<int>> (array, 8);
foreach<int, inc<int>> (array, 8);
foreach<int, dec<int>> (array, 8);

上面都将int重复两遍有点冗余。三个函数print,inc,dec都是函数模板。可以用带参数的模板传入，在foreach内进行实例化即可。只是需要将三个函数模板修改为类模板。
#include <iostream>

template<template<typename TT> class Func, typename T>
void foreach(T array[], unsigned size) {
    Func<T> func;
    for (unsigned i = 0; i < size; ++i)
        func(array[i]);
}

template<typename T>
struct inc {
    void operator() (T &v) const {++v;}
};

template<typename T>
struct dec {
    void operator() (T &v) const {--v;}
};

template<typename T>
struct print {
    void operator() (T &v) const { std::cout << " " << v;}
};

int main(int argc, char* argv[]) {
    int array[] = {1, 2, 3, 4, 5, 6, 7, 8};
    foreach<print>(array, 8);
    std::cout << std::endl;

    foreach<inc>(array, 8);
    foreach<print>(array, 8);
    std::cout << std::endl;

    foreach<dec>(array, 8);
    foreach<print>(array, 8);
    std::cout << std::endl;

    return 0;
}

HTTP 参数类型简介
请求头参数 （head）
路径参数 （path）
查询参数 （query）
请求体参数 （body）

http协议 传参类型 根据参数所在协议位置可分为 四大类
请求头参数 （head）
请求头参数顾名思义，是存放在请求头中发送给服务器的参数，服务器通过解析请求头获取参数内容。通常会存放本次请求的基本设置，以帮助服务器理解并解析本次请求的body体。

参数形式如：
Accept-Language : zh-CN,zh;q=0.8,zh-TW;q=0.5,en-US;q=0.3,en;q=0.2

其中 Accept-Language 为参数名称 :号后面紧跟请求的值。

ps:如上则表示本次请求的语言为中文和英文。 q用来标识语种权重 值在 0-1之间

服务器根据会这个请求头选择返回的语言

其他http协议中规定的参数及含义请参考 http请求头规范
当然我们也可以自定义请求头内容，参数名称和参数意义必须事先和服务器约定好否则没服务器无法理解你传输请求头的意义会忽略自定义参数。

其中 jQuery 添加请求头方式如下：
$.ajax({
          headers: {
              'Access-Token':$.cookie('access_token')
          }
      })


ps:cookies 是存放在每一条请求中的请求头上的特殊存储体 由于每次请求都会将全部cookies发送给服务器 所以不建议在cookies存储大量数据 ，也因此产生了session 技术，不过这是题外话了。

路径参数 （path）
路径参数顾名思义，本次请求的资源路径,紧跟请求域名的后面，服务器通过解析路径参数获取资源位置。路径参数是用/分隔的一系列字符串，其意义在于对服务器资源进行统一定位，如：
http://www.madmk.com/office/zhangsan

其中 /office/zhangsan 便是路径参数，其含义可解释为 找办公室里的张三，大多数情况下路径参数会代表服务器真实的文件路径。

REST API的兴起赋予了路径参数更为广阔的含义，有兴趣的朋友可以找一下有关 REST API 设计的文章。


ps:其中参数如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。

查询参数 （query）
查询参数，是房放在请求地址后面的参数同样以键值对进行标识形如：
userId=1

其中 userId 表示参数名称 1表示参数的值。参数名称为可重复的。

请求地址与参数之间用?进行分隔 多个参数之间用 &进行分隔，完整请求如下：
http://www.madmk.com/a/b/c?userId=1&userId=1&age=18&sex=男

大多数情况下使用 查询参数 进行传值的是GET请求，所有用表单提交的GET请求都会使用 查询参数 进行传参。

ps:其中参数如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。

请求体参数 （body）
请求体参数顾名思义，是存放在请求体中发送给服务器的参数。请求体参数格式复杂多变，服务器会先根据请求头中的 Content-Type 获取其格式，然后再根据其格式进行解析，常见的格式如下：




Content-Type值
内容格式
消息示例




application/from
表单传值，也是默认的解析形式,服务器会对表单进行解析
userId=1&userId=1&age=18&sex=男


text/plain
文本值，服务器会将本次请求的请求体当作普通字符串看待
Hello world


application/json
json,服务器会将请求体进行json解析，获取参数
{“userId”:1,“sex”:“男”}


application/xml
xml,服务器会将请求体进行xml解析，获取参数
参见 xml 标准格式


text/html
html,服务器会将请求体进行html解析，获取参数
参见 html 标准格式



ps:其中application/from类型如有中文 或特殊符号如/ ,:,?,#,+,=等需要进行转义处理。

类似的还有很多这里不一一列举。有兴趣可以翻一下，Content-Type介绍

welcome to my blog
python3.5对类型进行标注了, 但是貌似不检查具体类型是啥
下面的示例表示,name需要是str类型的, greeting()的返回值是str类型的, 但是传入其他类型的变量也不会报错, 只是起到了标注类型的作用
def greeting(name: str) -> str:
    return 'Hello ' + name

进一步
# 限制了a的参数类型为list, 返回值类型为tuple
def tmp0(a:list) -> tuple:
	pass

# 复杂一点的写法
from typing import List, Tuple, Dict
# 限制了返回值类型为列表, 并且列表的元素是int类型或者str类型
def tmp1(a:float, s:str) -> List[int or str]:
	pass


# 限制了返回值为元组类型, 并且元组内的元素类型依次为元组,字典,字符串,布尔
def tmp2(a:bool, s:str) -> Tuple[Tuple, Dict, str, bool]:
    pass

参考

官方文档链接

python模块分析之typing

昨天面试问了一个java的基础问题:switch中参数类型可以有哪些?
平时虽然有用过，但真没怎么注意switch中参数的类型。然后就随便蒙了一个答案，答对了。今天就对switch分析一下。在jdk1.7版本以前，参数类型只能是short、byte、int、char可正常运行。而例如String，Long、Integer、double、float等则会报错。
而jdk1.7版本以后，参数类型除了之前可使用的外，String、Integer类、 Character类、枚举类型都可以正常运行。而Long、double、float依旧会报错。
public class SwitchTest {
	public static void main(String[] args) {
		String str = "abcd";
		/*
		 * 可执行不报错
		 * Integer in = 12; int ii = 12; short sh = (short)12; char ch = 'c';
		 * byte by =(byte)12;
		 */
		/*
		 * 会报错
		 *  double dou = 0.12; long lo = 123L;float fl = 0.12f;
		 */
		switch (str) {
		case "abcd":
			System.out.println("String正确");
			break;
		case "idfd":
			System.out.println("idfd正确");
			break;
		default:
			System.out.println("错误");
			break;
		}

	}

}