css中列表分为三种:ul(无序列表)，ol(有序列表)，dl(自定义列表)。
无序列表:<ul>
<li></li>/*列表项*/
<li></li>
</ul>
有序列表:<ol>
<li></li>
<li></li>
</ol>
自定义列表:<dl>
<dl>/*项目名*/
<dd></dd>/ *项目*/
<dd></dd>
</dl>
</dl>
ul经常运用于导航:例<ul>
<li></li>
<li></li>
<li></li>
</ul>
css:导航左边水平排列:li{list-style:none;float:left;(margin:"";或者width:"";)}
水平右边排列:ul{float:left;}li{list-style:none;,float:left;}
float:left;}
转载于:https://www.cnblogs.com/chenslu/p/6939004.html
我纠结的问题都在primer上有很好的解答
之前突然想到，为什么要存在冒号这种初始化方法，在google被墙，没办法只能求助于度娘。。。
冒号这种初始化方法，也叫做，初始化列表，也就是变量初始化的时候调用的
意味着，在一个类当中，一个成员变量只能在初始化赋值。
比如： const, 比如引用&。
举个例子：
class A { public: A(i) { a = i; b = i; c = i; } private: int a; const int b; int &c; };
这样是不合法的， 因为b, c只能在初始化时赋值。
所以，只能如此初始化：
class A { public: A(int i):a(i), b(i), c(i){} private: int a; const int b; int &c; };还有一个比较重要的问题，就是初始化列表的初始化顺序是怎样的？
也就是说，a和b的值分别是多少？class A { public: A():b(a-1), a(b-1) { cout<<b<<endl; cout<<a<<endl; }; private: int a; int b; };1
-858993461答案就是，初始化列表里的顺序，与初始化顺序无关
这里首先定义的是a，所以a先初始化为b - 1即 -858993460 - 1，-858993461
而b是第二个定义的，所以后初始化b为a- 1即-858993461，为-858993462
如果，没有必要的情况下，还是少用初始化列表，尽量在构造函数中顺序的定义。
最近遇到了一个程序，一开始有些莫名其妙，最后经过思考、猜想、验证的过程，将其总结如下：
首先先上代码：
函数声明如下：
class Controller { using AnalysisManager = NST::analysis::AnalysisManager; using FiltrationManager = NST::filtration::FiltrationManager; class Running { public: inline Running(Controller&); Running() = delete; Running(const Running&) = delete; Running& operator=(const Running&) = delete; inline ~Running(); private: Controller& controller; }; public: Controller(const Parameters&); Controller(const Controller&) = delete; Controller& operator=(const Controller&) = delete; ~Controller(); int run(); private: // initializer for global outptut utils::Out::Global gout; // initializer for global logger utils::Log::Global glog; // storage for exceptions RunningStatus status; // signal handler SignalHandler signals; // controller subsystems std::unique_ptr<AnalysisManager> analysis; std::unique_ptr<FiltrationManager> filtration; };只看其构造函数：
Controller::Controller(const Parameters& params) try : gout {utils::Out::Level(params.verbose_level())} , glog {params.log_path()} , signals {status} , analysis {} , filtration {new FiltrationManager{status}} { // clang-format on switch(params.running_mode()) { case RunningMode::Profiling: { analysis.reset(new AnalysisManager{status, params}); if(analysis->isSilent()) utils::Out::Global::set_level(utils::Out::Level::Silent); filtration->add_online_analysis(params, analysis->get_queue()); } break; case RunningMode::Dumping: { filtration->add_online_dumping(params); } break; case RunningMode::Analysis: { analysis.reset(new AnalysisManager{status, params}); if(analysis->isSilent()) utils::Out::Global::set_level(utils::Out::Level::Silent); filtration->add_offline_analysis(params.input_file(), analysis->get_queue()); } break; case RunningMode::Draining: { filtration->add_offline_dumping(params); } break; } droproot(params.dropuser()); }对于上述的构造函数，涉及到的几个知识点总结如下：
一：C++11特性初始化参数列表
C++11引入了一个新的初始化方式，称为初始化列表(List Initialize)，具体的初始化方式如下：
int i = {1}; int j{3};
初始化列表在使用的时候有如下一些要求：
1. 当初始化内置基本类型的时候，列表初始化不允许出现隐式类型的转换，例如：
long double ld = 3.1415926536; int a{ld}, b = {ld}; //出错，不允许出现精度的丢失 int c(ld), d = ld; // 非列表初始化，但是会出现精度的丢失2. 初始化列表可以用于初始化结构体类型，例如：
#include <iostream> struct Person { std::string name; int age; }; int main() { Person p = {"Frank", 25}; std::cout << p.name << " : " << p.age << std::endl; }3. 其他一些不方便初始化的地方使用，比如std<vector>的初始化，如果不使用这种方式，只能用构造函数来初始化，难以达到效果：
std::vector<int> ivec1(3, 5); std::vector<int> ivec2 = {5, 5, 5}; std::vector<int> ivec3 = {1,2,3,4,5}; //不使用列表初始化用构造函数难以实现二：初始化列表的作用
对于构造函数而言，初始化列表的作用无非是在对成员变量申请内存时进行初始化。执行构造函数时，先执行初始化表的内容，若初始化里面里面没有数据，侧编译器安装系统默认的方式对成员变量申请内存，进行系统默认的方式赋值，随后再进行构造函数中花括号内部的指令。
A.对于引用型成员变量和const常量型成员变量，则必须通过初始化表初始化该成员变量。
B.如果有类类型成员变量，而该类型又没有无参构造函数，则必须通过初始化表初始化该成员变量。
C.需要在子类中指定其基类部分的初始化方式，必须使用初始化表。
D.成员变量初始化顺序有声明顺序决定，而与初始化表的顺序无关。
E.对于参数列表中所列的成员变量，可以不包含所有的成员变量。三：delete的作用
为了能够显式的禁用某个函数，C++11 标准引入了一个新特性：deleted 函数。程序员只需在函数声明后加上“=delete;”，就可将该函数禁用。类 X 的拷贝构造函数以及拷贝赋值操作符声明为 deleted 函数，就可以禁止类 X 对象之间的拷贝和赋值
c++中构造函数有初始化列表，目的是用于变量的初始化。
百度初始化列表会告诉你初始化列表能够提高构造函数的性能，在派生类中可以跳过基类构造函数，直接进行赋值操作。下面是一常见派生类中使用初始化列表的例子。
class A { public: A(int i = 0):a(i){} //基类初始化成员变量 protected: int a; }; class B :public A { public: B():a(5){}//派生类不能初始化基类成员变量 };这样是正确的：也可以这样：#include<iostream> usingnamespace std; class A { protected: int a; public: A(int i = 0):a(i) {} }; class B :public A { public: B():A(5){}//基类的成员函数 void printinfo() { cout<< a<< endl; } };#include<iostream> usingnamespace std; class A { public: A(int i = 0):a(i) {} protected: int a; }; class B :publicA { public: B() {a=5;} };
其中为什么要使用初始化列表是因为：
1.常量成员，因为常量只能初始化不能赋值，所以必须放在初始化列表里面；2.引用类型，引用必须在定义的时候初始化，并且不能重新赋值，所以也要写在初始化列表里面；3. 没有默认构造函数的类类型，因为使用初始化列表可以不必调用默认构造函数来初始化，而是直接调用拷贝构造函数初始化。另外一个重点问题是：成员是按照他们在类中出现的顺序进行初始化的，而不是按照他们在初始化列表出现的顺序初始化的。#include <iostream> #include <string> using namespace std; class base { private: int m_i; int m_j; public: base(int i): m_j(i), m_i(m_j){}//这里改变顺序 base():m_j(0),m_i(m_j){} int get_i() { return m_i; } int get_j() { return m_j; } }; class A { static const int size=0;//静态，常量，整型才可以直接初始化。其他都不可以。 }; int main(int argc, char* argv) { base obj(98); cout<<obj.get_i()<<endl<<obj.get_j()<<endl; base nn; cout<<nn.get_i()<<endl<<nn.get_j()<<endl; A nb; return 0; }
这里就有一个有趣的问题，虽然m_j出现在m_i前面，但m_i在m_j前面定义，所以先初始化m_i，此时m_j还是随机数，所以m_i就被初始化为一个随机数。建议：按照成员的定义顺序进行初始化！
