WHATWHATWHAT

最新推荐文章于 2021-02-16 03:56:39 发布
最新推荐文章于 2021-02-16 03:56:39 发布
阅读量306 收藏
点赞数





00000000000000000000000000000000000000000000000000000000000000000000000000000000000000

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000

 boost::signals2::signal<std::string (const char* psz)> Translate;


boost::signals2::signal

translationInterface.Translate.connect(Translate);

   uiInterface.NotifyHeaderTip.connect(boost::bind(BlockTipChanged, this, _1, _2, true));

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

boost::thread ------------------join


000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

boost::this_thread::interruption_point();


线程不是在任意时刻都可以被中断的。如果将线程中函数中的sleep()睡眠等待去掉，那么即使在主线程中调用interrupt()线程也不会被中断。
thread库预定义了若干个线程的中断点，只有当线程执行到中断点的时候才能被中断，一个线程可以拥有任意多个中断点。

thread库预定义了共9个中断点，它们都是函数，如下：

1. thread::join();
2. thread::timed_join();
3. condition_variable::wait();
4. condition_variable::timed_wait();
5. condition_variable_any::wait();
6. condition_variable_any::timed_wait();
7. thread::sleep();
8. this_thread::sleep();
9. this_thread::interruption_point()
这些中断点中的前8个都是某种形式的等待函数，表明线程在阻塞等待的时候可以被中断。

而最后一个位于子名字空间this_thread的interruption_point()则是一个特殊的中断点函数，它并不等待，只是起到一个标签的作用，表示线程执行到这个函数所在的语句就可以被中断。看看下面的例子：

[cpp] view plain copy
  1. namespace  
  2. {  
  3.     boost::mutex io_mu;  
  4.   
  5.     void to_interrupt(const std::string& str)  
  6.     {  
  7.         // 如果在线程外部调用了this_thread->interrupt()  
  8.         // 线程内部的以下这些检查点可以抛出boost::thread_interrupted异常  
  9.         try  
  10.         {  
  11.             boost::this_thread::disable_interruption();  
  12.             for (int i = 0; i < 5; ++i)  
  13.             {  
  14.                 boost::mutex::scoped_lock lock(io_mu);  
  15.                 PRINT_DEBUG(i);  
  16.                 PRINT_DEBUG(std::boolalpha << boost::this_thread::interruption_enabled());  
  17.                 // PRINT_DEBUG(std::boolalpha << boost::this_thread::interruption_requested());  
  18.                 if (i == 2)  
  19.                 {  
  20.                     PRINT_DEBUG(std::boolalpha << boost::this_thread::interruption_enabled());  
  21.                     boost::this_thread::interruption_point();  
  22.                     PRINT_DEBUG(std::boolalpha << boost::this_thread::interruption_enabled());  
  23.                 }  
  24.             }  
  25.         }  
  26.         catch (boost::thread_interrupted &)  
  27.         {  
  28.         }  
  29.     }      
  30. }  
  31.   
  32. void test_thread_interrupt()  
  33. {  
  34.     boost::thread t(to_interrupt, "hello");  
  35.     // 中断函数  
  36.     t.interrupt();  
  37.     t.join();  
  38. }  
运行结果：
[cpp] view plain copy
  1. 2013-01-02 11:00:44 263 [8272] DEBUG - 0  
  2. 2013-01-02 11:00:44 266 [8272] DEBUG - 1  
  3. 2013-01-02 11:00:44 269 [8272] DEBUG - 2  
如果注释boost::this_thread::interrupt_point了，则结果如下：
[cpp] view plain copy
  1. 2013-01-02 11:02:06 555 [5168] DEBUG - 0  
  2. 2013-01-02 11:02:06 559 [5168] DEBUG - 1  
  3. 2013-01-02 11:02:06 561 [5168] DEBUG - 2  
  4. 2013-01-02 11:02:06 564 [5168] DEBUG - 3  
  5. 2013-01-02 11:02:06 567 [5168] DEBUG - 4  
下面谈谈启用/禁用线程中断
缺省情况下钱程都是允许中断的，但thread库允许控制线程的中断行为。
thread 库在子名字空间this_thread提供了一组函数和类来共同完成线程的中断启用和禁用:
1. interruption_enabled(): 函数检测当前线程是否允许中断
2. interruption_requested(): 函数检测当前线程是否被要求中断
3. 类disable_interruption是一个RAII类型的对象，它在构造时关闭线程的中断，析构时自动恢复线程的中断状态。在disable_interruption 的生命期内线程始终是不可中断的，除非使用了restore_interruption 对象。
4. restore_interruption只能在disable_interruption 的作用域内使用，它在构造时临时打开线程的中断状态，在析构时又关闭中断状态。
这些中断点中的前8个都是某种形式的等待函数，表明线程在阻塞等待的时候可以被中断。
[cpp] view plain copy
  1. namespace  
  2. {  
  3.     boost::mutex io_mu;  
  4.   
  5.     void to_interrupt_disable(const std::string& str)  
  6.     {  
  7.         // 默认可以中断  
  8.         assert(boost::this_thread::interruption_enabled());  
  9.           
  10.         for (int i = 0; i < 10; i++)  
  11.         {  
  12.             // 关闭中断  
  13.             boost::this_thread::disable_interruption di;            
  14.             // 此时中断不可用  
  15.             PRINT_DEBUG(std::boolalpha << "interruption_enabled = " <<  boost::this_thread::interruption_enabled());  
  16.             // 是否有中断请求  
  17.             PRINT_DEBUG(std::boolalpha << "interruption_requested = " <<  boost::this_thread::interruption_requested());  
  18.   
  19.             boost::mutex::scoped_lock lock(io_mu);  
  20.             PRINT_DEBUG(i);  
  21.             // 使用中断点函数，因为关闭中断，此时无效果。 中断恢复后，它才生效。  
  22.             boost::this_thread::interruption_point();  
  23.   
  24.             if (i == 8)  
  25.             {  
  26.                 // 临时恢复中断  
  27.                 boost::this_thread::restore_interruption ri(di);  
  28.                 PRINT_DEBUG(std::boolalpha << "interruption_enabled = " <<  boost::this_thread::interruption_enabled());  
  29.                 PRINT_DEBUG(std::boolalpha << "interruption_enabled after restore = " <<  boost::this_thread::interruption_enabled());  
  30.                 boost::this_thread::interruption_point();  
  31.             }  
  32.         }  
  33.     }  
  34. }  
  35.   
  36. void test_thread_interrupt_disable()  
  37. {  
  38.     boost::thread t(to_interrupt_disable, "hello");  
  39.     t.interrupt();  
  40.     t.join();  
  41. }  
结果：
[cpp] view plain copy
  1. 2013-01-02 14:09:35 538 [7628] DEBUG - interruption_enabled = false  
  2. 2013-01-02 14:09:35 544 [7628] DEBUG - interruption_requested = true  
  3. 2013-01-02 14:09:35 551 [7628] DEBUG - 0  
  4. 2013-01-02 14:09:35 555 [7628] DEBUG - interruption_enabled = false  
  5. 2013-01-02 14:09:35 563 [7628] DEBUG - interruption_requested = true  
  6. 2013-01-02 14:09:35 570 [7628] DEBUG - 1  
  7. 2013-01-02 14:09:35 574 [7628] DEBUG - interruption_enabled = false  
  8. 2013-01-02 14:09:35 581 [7628] DEBUG - interruption_requested = true  
  9. 2013-01-02 14:09:35 586 [7628] DEBUG - 2  
  10. 2013-01-02 14:09:35 589 [7628] DEBUG - interruption_enabled = false  
  11. 2013-01-02 14:09:35 601 [7628] DEBUG - interruption_requested = true  
  12. 2013-01-02 14:09:35 608 [7628] DEBUG - 3  
  13. 2013-01-02 14:09:35 614 [7628] DEBUG - interruption_enabled = false  
  14. 2013-01-02 14:09:35 621 [7628] DEBUG - interruption_requested = true  
  15. 2013-01-02 14:09:35 627 [7628] DEBUG - 4  
  16. 2013-01-02 14:09:35 630 [7628] DEBUG - interruption_enabled = false  
  17. 2013-01-02 14:09:35 637 [7628] DEBUG - interruption_requested = true  
  18. 2013-01-02 14:09:35 643 [7628] DEBUG - 5  
  19. 2013-01-02 14:09:35 646 [7628] DEBUG - interruption_enabled = false  
  20. 2013-01-02 14:09:35 650 [7628] DEBUG - interruption_requested = true  
  21. 2013-01-02 14:09:35 655 [7628] DEBUG - 6  
  22. 2013-01-02 14:09:35 659 [7628] DEBUG - interruption_enabled = false  
  23. 2013-01-02 14:09:35 663 [7628] DEBUG - interruption_requested = true  
  24. 2013-01-02 14:09:35 667 [7628] DEBUG - 7  
  25. 2013-01-02 14:09:35 670 [7628] DEBUG - interruption_enabled = false  
  26. 2013-01-02 14:09:35 679 [7628] DEBUG - interruption_requested = true  
  27. 2013-01-02 14:09:35 685 [7628] DEBUG - 8  
  28. 2013-01-02 14:09:35 689 [7628] DEBUG - interruption_enabled = true  
  29. 2013-01-02 14:09:35 695 [7628] DEBUG - interruption_enabled after restore = true 


000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000




C++并发实战2：thread::join和thread::detach

原创 2013年12月02日 14:11:29

    thread::join()是个简单暴力的方法，主线程等待子进程期间什么都不能做，一般情形是主线程创建thread object后做自己的工作而不是简单停留在join上。thread::join()还会清理子线程相关的内存空间，此后thread object将不再和这个子线程相关了，即thread object不再joinable了，所以join对于一个子线程来说只可以被调用一次，为了实现更精细的线程等待机制，可以使用条件变量等机制。

      异常环境下join，假设主线程在一个函数f()里面创建thread object,接着f()又调用其它函数g(),那么确保在g()以任何方式下退出主线程都能join子线程。如：若g()通过异常退出，那么f()需要捕捉异常后join

[cpp] view plain copy
  1. #include<iostream>  
  2. #include<boost/thread.hpp>  
  3. void do_something(int& i){  
  4.     i++;  
  5. }  
  6. class func{  
  7.     public:  
  8.         func(int& i):i_(i){}  
  9.         void operator() (){  
  10.             for(int j=0;j<100;j++)  
  11.                 do_something(i_);  
  12.         }  
  13.     public:  
  14.         int& i_;  
  15. };  
  16. void do_something_in_current_thread(){}  
  17. void f(){  
  18.     int local=0;  
  19.     func my_func(local);  
  20.     boost::thread t(my_func);  
  21.     try{  
  22.         do_something_in_current_thread();  
  23.     }  
  24.     catch(...){  
  25.         t.join();//确保在异常条件下join子线程  
  26.         throw;  
  27.     }  
  28.     t.join();  
  29. }  
  30. int main(){  
  31.     f();  
  32.     return 0;  
  33. }  


      上面的方法看起来笨重，有个解决办法是采用RAII(资源获取即初始化)，将一个thread object通过栈对象A管理，在栈对象A析构时调用thread::join.按照局部对象析构是构造的逆序，栈对象A析构完成后再析构thread object。如下：
[cpp] view plain copy
  1. #include<iostream>  
  2. #include<boost/noncopyable.hpp>  
  3. #include<boost/thread.hpp>  
  4. using namespace std;  
  5. class thread_guard:boost::noncopyable{  
  6.     public:  
  7.         explicit thread_guard(boost::thread& t):t_(t){}  
  8.         ~thread_guard(){  
  9.             if(t_.joinable()){//检测是很有必要的，因为thread::join只能调用一次，要防止其它地方意外join了  
  10.                t_.join();  
  11.             }  
  12.         }  
  13.         //thread_guard(const thread_guard&)=delete;//c++11中这样声明表示禁用copy constructor需要-std=c++0x支持，这里采用boost::noncopyable已经禁止了拷贝和复制  
  14.         //thread_guard& operator=(const thread_guard&)=delete;  
  15.     private:  
  16.         boost::thread& t_;  
  17. };  
  18. void do_something(int& i){  
  19.     i++;  
  20. }  
  21. class func{  
  22.     public:  
  23.         func(int& i):i_(i){}  
  24.         void operator()(){  
  25.             for(int j=0;j<100;j++)  
  26.                 do_something(i_);  
  27.         }  
  28.     public:  
  29.         int& i_;  
  30. };  
  31. void do_something_in_current_thread(){}  
  32. void fun(){  
  33.     int local=0;  
  34.     func my_func(local);  
  35.     boost::thread t(my_func);  
  36.     thread_guard g(t);  
  37.     do_something_in_current_thread();  
  38. }  
  39. int main(){  
  40.     fun();  
  41.     return 0;  
  42. }  

    说明：禁止拷贝和复制的原因是防止栈对象thread_guard在超出了thread object对象生命期的地方使用。如果detach一个线程则没有上述这么麻烦，必经detach后就不管子线程了。


     thread::detach()后：没有直接方法与线程通信，不可能wait了，不可能有任何thread object指向这个线程。线程变成了后台进程(孤儿进程)，在Linux将由init接管，在c++中由库接管。若不确定一个线程是否有thread object指向它，那么请先用thread::joinable()检测后再thread::detach()就想前面代码中的joinable检测一样。

      考虑一个情形：通常我们在word中编辑文件A时，点击"新建"按钮后会出现新的窗口继续编辑文件B。这里A和B是相对独立的，A"新建"相当于开启一个线程去供B使用，其后A马上detach这个线程。代码如下：

[cpp] view plain copy
  1. #include<iostream>  
  2. #include<boost/thread.hpp>  
  3. void open_document_and_display_gui(const std::string& filename){}//“新建”这一操作  
  4. bool done_eaditing(){//是否完成编辑  
  5.     return true;  
  6. }  
  7. enum command_type{open_new_document};//用户命令，这里只有一个就是“新建”  
  8. class user_command{//用户命令封装  
  9.     public:  
  10.         user_command():type(open_new_document){}  
  11.     public:  
  12.         command_type type;  
  13. };  
  14. user_command get_user_input(){//获取用户命令，这里就是获取"新建“  
  15.     return user_command();  
  16. }  
  17. std::string get_filename_from_user(){  
  18.     return "foo.doc";  
  19. }  
  20. void process_user_input(const user_command& cmd){}//处理用户的普通输入，即文档编写  
  21.   
  22. void edit_document(const std::string& filename){//假设初始时文档A执行edit_document，发现用户有”新建“命令到达，则开启一个线程去供文档B使用，且立即detach这个线程  
  23.     open_document_and_display_gui(filename);  
  24.     while(!done_eaditing()){  
  25.         user_command cmd=get_user_input();  
  26.         if(cmd.type==open_new_document){  
  27.             const std::string new_name=get_filename_from_user();  
  28.             boost::thread t(edit_document,new_name);//文档B也是采用同样的线程函数，这里可以看出thread可以接收参数，还有一个方法参考pthread_create将参数封装在一个函数对象中，然后传给thread  
  29.             t.detach();//立即执行detach，这里可以肯定thread t和线程相关，故不需要检测joinable  
  30.         }  
  31.         else  
  32.             process_user_input(cmd);//普通文档编辑  
  33.     }  
  34. }  
  35. int main(){  
  36.     edit_document("bar.doc");  
  37.     return 0;  
  38. } 
000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000


线程状态：

在一个线程的生存期内，可以在多种状态之间转换，不同的操作系统可以实现不同的线程模型，定义许多不同的线程状态，每个状态还可以包含多个子状态，但大体来说，如下几种状态是通用的：

1）就绪：参与调度，等待被执行，一旦被调度选中，立即开始执行

2）运行：占用CPU，正在运行中

3）休眠：暂不参与调度，等待特定事件发生

4）中止：已经运行完毕，等待回收线程资源

线程环境：

线程存在于进程之中，进程内所有全局资源对于内部每个线程都是可见的。

进程内典型全局资源如下：

1）代码区：这意味着当前进程空间内所有的可见的函数代码，对于每个线程来说，也是可见的

2）静态存储区：全局变量，静态空间

3）动态存储区：堆空间

线程内典型的局部资源：

1）本地栈空间：存放本线程的函数调用栈，函数内部的局部变量等

2）部分寄存器变量：线程下一步要执行代码的指针偏移量

一个进程发起后，会首先生成一个缺省的线程，通常称这个线程为主线程，C/C++程序中，主线程就是通过main函数进入的线程，由主线程衍生的线程成为从线程，从线程也可以有自己的入口函数，相当于主线程的main函数，这个函数由用户指定。通过thread构造函数中传入函数指针实现，在指定线程入口函数时，也可以指定入口函数的参数。就像main函数有固定的格式要求一样，线程的入口函数也可以有固定的格式要求，参数通常都是void*类型，返回类型根据协议的不同也不同，pthread中是void*，winapi中是unsigned int，而且都是全局函数。

最常见的线程模型中，除主线程较为特殊之外，其他线程一旦被创建，相互之间就是对等关系，不存在隐含的层次关系。每个进程可创建的最大线程数由具体实现决定。

无论在windows中还是Posix中，主线程和子线程的默认关系是：无论子线程执行完毕与否，一旦主线程执行完毕退出，所有子线程执行都会终止。这时整个进程结束或僵死，部分线程保持一种终止执行但还未销毁的状态，而进程必须在其所有线程销毁后销毁，这时进程处于僵死状态。线程函数执行完毕退出，或以其他非常方式终止，线程进入终止态，但是为线程分配的系统资源不一定释放，可能在系统重启之前，一直都不能释放，终止态的线程，仍旧作为一个线程实体存在于操作系统中，什么时候销毁，取决于线程属性。在这种情况下，主线程和子线程通常定义以下两种关系：

1、可会合（joinable）：这种关系下，主线程需要明确执行等待操作，在子线程结束后，主线程的等待操作执行完毕，子线程和主线程会合，这时主线程继续执行等待操作之后的下一步操作。主线程必须会合可会合的子线程。在主线程的线程函数内部调用子线程对象的wait函数实现，即使子线程能够在主线程之前执行完毕，进入终止态，也必须执行会合操作，否则，系统永远不会主动销毁线程，分配给该线程的系统资源也永远不会释放。

2、相分离（detached）：表示子线程无需和主线程会合，也就是相分离的，这种情况下，子线程一旦进入终止状态，这种方式常用在线程数较多的情况下，有时让主线程逐个等待子线程结束，或者让主线程安排每个子线程结束的等待顺序，是很困难或不可能的，所以在并发子线程较多的情况下，这种方式也会经常使用。


在任何一个时间点上，线程是可结合（joinable）或者是可分离的（detached），一个可结合的线程能够被其他线程回收资源和杀死，在被其他线程回收之前，它的存储器资源如栈，是不释放的，相反，一个分离的线程是不能被其他线程回收或杀死的，它的存储器资源在它终止时由系统自动释放。

线程的分离状态决定一个线程以什么样的方式来终止自己，在默认的情况下，线程是非分离状态的，这种情况下，原有的线程等待创建的线程结束，只有当pthread_join函数返回时，创建的线程才算终止，释放自己占用的系统紫云啊，而分离线程没有被其他的线程所等待，自己运行结束了，线程也就终止了，马上释放系统资源。




0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000



signals2基于Boost的另一个库signals，实现了线程安全的观察者模式。在signals2库中，观察者模式被称为信号/插槽(signals and slots)，他是一种函数回调机制，一个信号关联了多个插槽，当信号发出时，所有关联它的插槽都会被调用。


许多成熟的软件系统都用到了这种信号/插槽机制(另一个常用的名称是事件处理机制：event/event handler)，它可以很好地解耦一组互相协作的类，有的语言设置直接内建了对它的支持(如c#)，signals2以库的形式为c++增加了这个重要的功能。

 

1、操作函数

signal最重要的操作函数是插槽管理connect()函数，它吧插槽连接到信号上，相当于为信号(事件)增加了一个处理的handler。

插槽可以是任意的可调用对象，包括函数指针、函数对象、以及它们的bind表达式和function对象，signal内部使用function作为容器来保存这些可调用对象。连接时可以指定组号也可以不指定组号，当信号发生时将依据组号的排序准则依次调用插槽函数。

如果连接成功connect()将返回一个connection，表示了信号与插槽之间的连接关系，它是一个轻量级的对象，可以处理两者间的连接，如断开、重连接、或者测试连接状态。

成员函数disconnect()可以断开插槽与信号的连接，它有两种形式：传递组号将断开该组的所有插槽，传递一个插槽对象将仅断开该插槽。函数disconnect_all_slots()可以一次性断开信号的所有插槽连接。

 

2、插槽的连接于使用

signal就像一个增强的function对象，它可以容纳(使用connect())多个符合模板参数中函数签名类型的函数(插槽)，形成一个插槽链表，然后在信号发生时一起调用：

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "iostream"  
  10. using namespace std;  
  11.   
  12.   
  13. void slots1()  
  14. {  
  15.     cout << "slots1 call" << endl;  
  16. }  
  17.   
  18. void slots2()  
  19. {  
  20.     cout << "slots2 call" << endl;  
  21. }  
  22.   
  23.   
  24. struct Hello  
  25. {  
  26.     void operator()() const   
  27.     {  
  28.         std::cout << "Hello";  
  29.     }  
  30. };  
  31.   
  32. int _tmain(int argc, _TCHAR* argv[])  
  33. {  
  34.     boost::signals2::signal<void()> sig;  
  35.     sig.connect(&slots1);  
  36.     sig.connect(&slots2);  
  37.   
  38.     sig();  
  39.   
  40.     boost::signals2::signal<void ()> sig1;  
  41.   
  42.     sig1.connect(Hello());  
  43.     sig1();  
  44.   
  45.   
  46.     return 0;  
  47. }  

注：编译这个程序的时候，确保已经在stdafx.h中加入#define _SCL_SECURE_NO_WARNINGS或者，在C/C++----预处理器----预处理器定义中加上了_SCL_SECURE_NO_WARNINGS，否则会引发错误(或不能正确输出)，下同。

在连接插槽时省了了connect()的第二个参数connect_position，它的缺省值是at_back，表示插槽将插入到信号插槽链表的尾部，因此slot2将在slot1之后被调用。


下面是使用和组号的情况：

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "iostream"  
  10. using namespace std;  
  11.   
  12.   
  13. template<int N>  
  14. struct Slot  
  15. {  
  16.     void operator()()  
  17.     {  
  18.         cout << "Slot current N value is : " << N << endl;  
  19.     }  
  20. };  
  21.   
  22.   
  23. int _tmain(int argc, _TCHAR* argv[])  
  24. {  
  25.     boost::signals2::signal<void()> sig;  
  26.   
  27.     sig.connect(Slot<1>(), boost::signals2::at_back);  // 最后一个被调用  
  28.     sig.connect(Slot<99>(), boost::signals2::at_front);  // 第一个被调用  
  29.   
  30.     sig.connect(5, Slot<55>(), boost::signals2::at_back); // 组号5的最后一个  
  31.     sig.connect(5, Slot<57>(), boost::signals2::at_front);// 组号5的第一个  
  32.   
  33.     sig.connect(10, Slot<100>());// 组号10该组只有一个  
  34.   
  35.     sig();  
  36.   
  37.     return 0;  
  38. }  



3、信号的返回值

signal如function一样，不仅可以把输入参数转发给所以插槽，也可以传回插槽的返回值。默认情况下signal使用合并器optional_last_value<R>，它将使用optional对象返回最后被调用的插槽的返回值。

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "iostream"  
  10. using namespace std;  
  11.   
  12.   
  13. template<int N>  
  14. struct Slot  
  15. {  
  16.     int operator()(int x)  
  17.     {  
  18.         cout << "Slot current N * x value is : " << endl;  
  19.   
  20.         return (N * x);  
  21.     }  
  22. };  
  23.   
  24.   
  25. int _tmain(int argc, _TCHAR* argv[])  
  26. {  
  27.     boost::signals2::signal<int(int)> sig;  
  28.   
  29.     sig.connect(Slot<10>());  
  30.     sig.connect(Slot<100>());  
  31.     cout << *sig(2) << endl;;  
  32.   
  33.     return 0;  
  34. }  

signal的operator()调用这时需要传入一个整数参数，这个参数会被signal存储一个拷贝，然后转发给各个插槽。最后signal将返回插槽链表末尾slots<100>()的计算结果，它是一个optional对象，必须用接引用操作符*来获得值(但你可以发现Slotcurrent N * x value is是输出了两次的)。

4、合并器

大多数时候，插槽的返回值都是有意义的，需要以某种方式处理多个插槽的返回值。

signal允许用户自定义合并器来处理插槽的返回值，把多个插槽的返回值合并为一个结果返回给用户。

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "numeric"  
  10. #include "iostream"  
  11. using namespace std;  
  12.   
  13.   
  14. template<int N>  
  15. struct Slot  
  16. {  
  17.     int operator()(int x)  
  18.     {  
  19.         cout << "Slot current N * x value is : " << endl;  
  20.   
  21.         return (N * x);  
  22.     }  
  23. };  
  24.   
  25.   
  26. template<typename T>  
  27. class combiner  
  28. {  
  29. public:  
  30.     typedef pair<T, T> result_type;  
  31.     combiner(T t = T()) : v(t)  
  32.     {  
  33.   
  34.     }  
  35.   
  36.     template<typename InputIterator>  
  37.     result_type operator()(InputIterator begin, InputIterator end) const  
  38.     {  
  39.         if (begin == end)  
  40.         {  
  41.             return result_type();  
  42.         }  
  43.   
  44.         vector<T> vec(begin, end);  
  45.         T sum = accumulate(vec.begin(), vec.end(), v);  
  46.         T max = *max_element(vec.begin(), vec.end());  
  47.   
  48.         return result_type(sum, max);  
  49.     }  
  50.   
  51. private:  
  52.     T v;  
  53. };  
  54.   
  55.   
  56. int _tmain(int argc, _TCHAR* argv[])  
  57. {  
  58.     boost::signals2::signal<int(int), combiner<int> > sig;  
  59.   
  60.     sig.connect(Slot<10>());  
  61.     sig.connect(Slot<20>());  
  62.     sig.connect(Slot<3>());  
  63.   
  64.     BOOST_AUTO(x, sig(2));  
  65.     cout << x.first << ", " << x.second << endl;  
  66.   
  67.     return 0;  
  68. }  

combiner类的调用操作符operator()的返回值类型可以是任意类型，完全由用户指定，不一定必须是optional或者是插槽的返回值类型。operator()的模板参数InputIterator是插槽链表的返回值迭代器，可以使用它来遍历所有插槽的返回值，进行所需的处理。


当信号被调用时，signal会自动把引用操作转换为插槽调用，将调用给定的合并器的operator()逐个处理插槽的返回值，并最终返回合并器operator()的结果。


如果我们不适用signal的缺省构造函数，而是在构造signal时传入一个合并器的实例，那么signal将使用逐个合并器(的拷贝)处理返回值。例如，下面的代码使用了一个有初值的合并器对象，累加值从100开始：

signal<int(int),combiner<int> > sig(combiner<int>(100));


5、管理信号的连接

信号与插槽的链接并不要求是永久的，当信号调用玩插槽后，有可能需要把插槽从信号中断开，再连接到其他的信号上去。

signal可以用成员函数disconnect()断开一个或一组插槽，或者使用disconnect_all_slots()断开所有插槽连接，函数empty()和num_slots()用来检测信号当前插槽的连接状态。

要断开一个插槽，插槽必须能够进行登记等价比较，对于函数对象来说就是重载一个等价语义的operator==。下面对slots<N>增加一个等价比较：

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "numeric"  
  10. #include "iostream"  
  11. using namespace std;  
  12.   
  13.   
  14. template<int N>  
  15. struct Slot  
  16. {  
  17.     int operator()(int x)  
  18.     {  
  19.         cout << "Slot current N * x value is : " << endl;  
  20.   
  21.         return (N * x);  
  22.     }  
  23. };  
  24.   
  25. template<int N>  
  26. bool operator== (const Slot<N>& a, const Slot<N>& b)  
  27. {  
  28.     return true;  
  29. }  
  30.   
  31. template<typename T>  
  32. class combiner  
  33. {  
  34. public:  
  35.     typedef pair<T, T> result_type;  
  36.     combiner(T t = T()) : v(t)  
  37.     {  
  38.   
  39.     }  
  40.   
  41.     template<typename InputIterator>  
  42.     result_type operator()(InputIterator begin, InputIterator end) const  
  43.     {  
  44.         if (begin == end)  
  45.         {  
  46.             return result_type();  
  47.         }  
  48.   
  49.         vector<T> vec(begin, end);  
  50.         T sum = accumulate(vec.begin(), vec.end(), v);  
  51.         T max = *max_element(vec.begin(), vec.end());  
  52.   
  53.         return result_type(sum, max);  
  54.     }  
  55.   
  56. private:  
  57.     T v;  
  58. };  
  59.   
  60.   
  61. int _tmain(int argc, _TCHAR* argv[])  
  62. {  
  63.     boost::signals2::signal<int(int)> sig;  
  64.  // assert(sig.empty());  
  65.    
  66.     sig.connect(0, Slot<10>());  
  67.     sig.connect(Slot<20>());  
  68.     sig.connect(1, Slot<30>());  
  69.   
  70.     assert(sig.num_slots() == 3);  
  71.     sig.disconnect(0);  
  72.   
  73. //  assert(sig.num_slots() == 1);  
  74.     sig.disconnect(Slot<30>());  
  75.   
  76. //  assert(sig.empty());  
  77.   
  78.     sig(2);  
  79.   
  80.     return 0;  
  81. }  

6、更灵活的管理信号连接

signals2库提供另外一种较为灵活的连接管理方式：使用connection对象。

每当signal使用connect()连接插槽时，他就会返回一个connection对象。connection对象像是信号与插槽连接关系的一个句柄(handle)，可以管理链接：

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "numeric"  
  10. #include "iostream"  
  11. using namespace std;  
  12.   
  13.   
  14. template<int N>  
  15. struct Slot  
  16. {  
  17.     int operator()(int x)  
  18.     {  
  19.         cout << "Slot current N * x value is : " << endl;  
  20.   
  21.         return (N * x);  
  22.     }  
  23. };  
  24.   
  25. template<int N>  
  26. bool operator== (const Slot<N>& a, const Slot<N>& b)  
  27. {  
  28.     return true;  
  29. }  
  30.   
  31. template<typename T>  
  32. class combiner  
  33. {  
  34. public:  
  35.     typedef pair<T, T> result_type;  
  36.     combiner(T t = T()) : v(t)  
  37.     {  
  38.   
  39.     }  
  40.   
  41.     template<typename InputIterator>  
  42.     result_type operator()(InputIterator begin, InputIterator end) const  
  43.     {  
  44.         if (begin == end)  
  45.         {  
  46.             return result_type();  
  47.         }  
  48.   
  49.         vector<T> vec(begin, end);  
  50.         T sum = accumulate(vec.begin(), vec.end(), v);  
  51.         T max = *max_element(vec.begin(), vec.end());  
  52.   
  53.         return result_type(sum, max);  
  54.     }  
  55.   
  56. private:  
  57.     T v;  
  58. };  
  59.   
  60.   
  61. int _tmain(int argc, _TCHAR* argv[])  
  62. {  
  63.     boost::signals2::signal<int(int)> sig;  
  64.     boost::signals2::connection c1 = sig.connect(0, Slot<10>());  
  65.     boost::signals2::connection c2 = sig.connect(0, Slot<10>());  
  66.     boost::signals2::connection c3 = sig.connect(0, Slot<10>());  
  67.   
  68.     c1.disconnect();  
  69.     assert(sig.num_slots() == 2);  
  70.     assert(!c1.connected());  
  71.     assert(c2.connected());  
  72.   
  73.     return 0;  
  74. }  
[cpp] view plain copy
  1.   

另外一种连接管理对象是scoped_connection，它是connection的种类，提供类似scoped_ptr的RAII功能：插槽与信号的连接仅在作用域内生效，当离开作用域时连接就会自动断开。当需要临时连接信号时scoped_connection会非常有用：

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "numeric"  
  10. #include "iostream"  
  11. using namespace std;  
  12.   
  13.   
  14. template<int N>  
  15. struct Slot  
  16. {  
  17.     int operator()(int x)  
  18.     {  
  19.         cout << "Slot current N * x value is : " << endl;  
  20.   
  21.         return (N * x);  
  22.     }  
  23. };  
  24.   
  25. template<int N>  
  26. bool operator== (const Slot<N>& a, const Slot<N>& b)  
  27. {  
  28.     return true;  
  29. }  
  30.   
  31. template<typename T>  
  32. class combiner  
  33. {  
  34. public:  
  35.     typedef pair<T, T> result_type;  
  36.     combiner(T t = T()) : v(t)  
  37.     {  
  38.   
  39.     }  
  40.   
  41.     template<typename InputIterator>  
  42.     result_type operator()(InputIterator begin, InputIterator end) const  
  43.     {  
  44.         if (begin == end)  
  45.         {  
  46.             return result_type();  
  47.         }  
  48.   
  49.         vector<T> vec(begin, end);  
  50.         T sum = accumulate(vec.begin(), vec.end(), v);  
  51.         T max = *max_element(vec.begin(), vec.end());  
  52.   
  53.         return result_type(sum, max);  
  54.     }  
  55.   
  56. private:  
  57.     T v;  
  58. };  
  59.   
  60.   
  61. int _tmain(int argc, _TCHAR* argv[])  
  62. {  
  63.     boost::signals2::signal<int(int)> sig;  
  64.   
  65.     sig.connect(0, Slot<10>());  
  66.     assert(sig.num_slots() == 1);  
  67.     {  
  68.         boost::signals2::scoped_connection sc = sig.connect(0, Slot<20>());  
  69.         assert(sig.num_slots() == 2);  
  70.     }  
  71.     assert(sig.num_slots() == 1);  
  72.   
  73.     return 0;  
  74. }  

插槽与信号的连接一旦断开就不能再连接起来，connection不提供reconnet()这样的函数。但可以暂时地阻塞插槽与信号的连接，当信号发生时被阻塞的插槽将不会被调用，connection对象的blocked()函数可以检查插槽是否被阻塞。但被阻塞的插槽并没有断开与信号的链接，在需要的时候可以随时解除阻塞。


connection对象自身没有阻塞的功能，他需要一个辅助类shared_connection_block，它将阻塞connection对象，知道它被析构或者显式调用unblock()函数：

[cpp] view plain copy
  1. #include "stdafx.h"  
  2. #include "boost/utility/result_of.hpp"  
  3. #include "boost/typeof/typeof.hpp"  
  4. #include "boost/assign.hpp"  
  5. #include "boost/ref.hpp"  
  6. #include "boost/bind.hpp"  
  7. #include "boost/function.hpp"  
  8. #include "boost/signals2.hpp"  
  9. #include "numeric"  
  10. #include "iostream"  
  11. using namespace std;  
  12.   
  13.   
  14. template<int N>  
  15. struct Slot  
  16. {  
  17.     void operator()(int x)  
  18.     {  
  19.         cout << "Slot current N is : " << N << endl;  
  20.     }  
  21. };  
  22.   
  23. template<int N>  
  24. bool operator== (const Slot<N>& a, const Slot<N>& b)  
  25. {  
  26.     return true;  
  27. }  
  28.   
  29. template<typename T>  
  30. class combiner  
  31. {  
  32. public:  
  33.     typedef pair<T, T> result_type;  
  34.     combiner(T t = T()) : v(t)  
  35.     {  
  36.   
  37.     }  
  38.   
  39.     template<typename InputIterator>  
  40.     result_type operator()(InputIterator begin, InputIterator end) const  
  41.     {  
  42.         if (begin == end)  
  43.         {  
  44.             return result_type();  
  45.         }  
  46.   
  47.         vector<T> vec(begin, end);  
  48.         T sum = accumulate(vec.begin(), vec.end(), v);  
  49.         T max = *max_element(vec.begin(), vec.end());  
  50.   
  51.         return result_type(sum, max);  
  52.     }  
  53.   
  54. private:  
  55.     T v;  
  56. };  
  57.   
  58.   
  59. int _tmain(int argc, _TCHAR* argv[])  
  60. {  
  61.     boost::signals2::signal<void(int)> sig;  
  62.   
  63.     boost::signals2::connection c1 = sig.connect(0, Slot<10>());  
  64.     boost::signals2::connection c2 = sig.connect(0, Slot<20>());  
  65.   
  66.     assert(sig.num_slots() == 2);  
  67.     sig(2);  
  68.   
  69.     cout << "begin blocking..." << endl;  
  70.     {  
  71.         boost::signals2::shared_connection_block block(c1);  
  72.         assert(sig.num_slots() == 2);  
  73.         assert(c1.blocked());  
  74.         sig(2);  
  75.     }  
  76.       
  77.     cout << "end blocking.." << endl;  
  78.     assert(!c1.blocked());  
  79.     sig(2);  
  80.   
  81.     return 0;  
  82. }

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000

00000000000000000000000000000000000000000000000000000000000000000000000000000000000000

AAAAAAAAAAAAAAAAAAA静态类

一个类是对一个概念的描述。

一个静态类没有状态，因此就没有必要成为一个类

C++具有传值，传址，哑元功能

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


一. 函数的参数支持哑元
            哑元是一种没有参数名的参数，主要是为了函数间的区别以及向前兼容
二. 函数的参数可以指定默认值，当调用时没有传参，就以默认值进行函数调用。
三. 有默认值的形参必须靠右，声明和定义分开时，默认值必需在声明中指定，定义中不再指定。

[cpp] view plain copy
  1. //默认参数 与 哑元  
  2.   
  3.   
  4. #include <iostream>  
  5. using namespace std;  
  6.   
  7. /*   1 
  8.   
  9. void print(int *a,int n){ 
  10.     for (int i = 0; i<n; i++) { 
  11.         cout << a[i]; 
  12.     } 
  13.     cout << endl; 
  14. } 
  15.   
  16.  */  
  17.   
  18.   
  19. // 2.用空格分开输出的每一个数  
  20. /* 
  21. void print(int *a,int n){ 
  22.     for (int i = 0; i<n; i++) { 
  23.         cout << a[i] << ' '; 
  24.     } 
  25.     cout << endl; 
  26. } 
  27.  */  
  28.   
  29.   
  30.   
  31. // 3.想用星号分隔开呢？  
  32. /* 
  33. void print(int *a,int n){ 
  34.     for (int i = 0; i<n; i++) { 
  35.         cout << a[i] << '*'; 
  36.     } 
  37.     cout << endl; 
  38. } 
  39. */  
  40.   
  41.   
  42. // 4.随意用各种分隔符分开每个数  封装函数就是找出不同之处作为参数  
  43. /* 
  44.  * 
  45. void print(int *a,int n,char ch){ 
  46.     for (int i = 0; i<n; i++) { 
  47.         cout << a[i] << ch; 
  48.     } 
  49.     cout << endl; 
  50. } 
  51.  * 
  52.  */  
  53.   
  54.   
  55.   
  56. // 5.用中括号括起来输出的内容  
  57.   
  58. /* 
  59. void print(int *a,int n,char ch){ 
  60.     cout << '['; 
  61.     for (int i = 0; i<n; i++) { 
  62.         cout << a[i] << ch; 
  63.     } 
  64.     cout << ']'; 
  65.     cout << endl; 
  66. } 
  67. */  
  68.   
  69.   
  70.    
  71. // 6.有时候想要中括号  有时候不想要呢？  
  72. /* 
  73.  * 
  74. void print(int *a,int n,char ch,bool flag){ 
  75.     if (flag) { 
  76.         cout << '['; 
  77.     } 
  78.      
  79.     for (int i = 0; i<n; i++) { 
  80.         cout << a[i] << ch; 
  81.     } 
  82.      
  83.     if (flag) { 
  84.         cout << ']'; 
  85.     } 
  86.     cout << endl; 
  87. } 
  88.  
  89.  * 
  90.  */  
  91.   
  92.   
  93. #pragma 如果想要打印10000次，但是只有9999次的分隔符是空格 和需要中括号,只有一次的分隔符是星号*和不带中括号 ,如果只为了这一次特殊的，就要写9999次不特殊的  怎么办?   只需要给定默认参数即可  
  94.   
  95. // 7. C++中参数可以给默认值  
  96. void print(int *a,int n,char ch,bool flag = true){  
  97.     if (flag) {  
  98.         cout << '[';  
  99.     }  
  100.       
  101.     for (int i = 0; i<n; i++) {  
  102.         cout << a[i] << ch;  
  103.     }  
  104.       
  105.     if (flag) {  
  106.         cout << ']';  
  107.     }  
  108.     cout << endl;  
  109. }  
  110.   
  111.   
  112. //8. 默认情况下  我想用空格作为分隔符  
  113. void print2(int *a,int n,char ch = ' ',bool flag = true){  
  114.     if (flag) {  
  115.         cout << '[';  
  116.     }  
  117.       
  118.     for (int i = 0; i<n; i++) {  
  119.         cout << a[i] << ch;  
  120.     }  
  121.       
  122.     if (flag) {  
  123.         cout << ']';  
  124.     }  
  125.     cout << endl;  
  126. }  
  127.   
  128.   
  129. #pragma 注意哦  C++的默认值只能从右向左给  
  130. //这个函数我没有给定最后一个参数的默认值   你会发现报错  这就说明了默认值只能从右向左给定  
  131. //如果第四个没有给定默认值而给第三个参数默认值,那么当我传进来3个参数的时候，编译器不知道把我传的第3个给谁。。。。也就是右边的没有默认值的话 不能给左边的默认值  
  132. /* 
  133. void print3(int *a, int n, char ch = ' ', bool flag){ 
  134.    //省略一下 
  135. } 
  136.  */  
  137.   
  138.   
  139. // 9 .     我能不能什么分隔符都不用   第8个函数能不能满足？？？  
  140. //不满足  
  141.   
  142. //方法重载  
  143. /* 
  144. void print2(int *a,int n){ 
  145.     for (int i = 0; i<n; i++) { 
  146.         cout << a[i]; 
  147.     } 
  148.     cout << endl; 
  149. } 
  150. */  
  151.   
  152. #pragma 哑元参数   哑元参数没有实际意义,解决方法冲突  解决版本兼容(例如本来的版本里面有个函数有2个参数的  到现在这个版本这个函数只需要1个参数。如果把这个函数改成1个参数，那么就不兼容原来的了)  
  153. //10 . 哑元参数  随便给一个类型  不用变量名  
  154.   
  155.   
  156. void print2(int *a,int n,float){  
  157.     for (int i = 0; i<n; i++) {  
  158.         cout << a[i];  
  159.     }  
  160.     cout << endl;  
  161. }  
  162.   
  163.   
  164.   
  165.   
  166. //主函数  
  167. int main(){  
  168.     //声明数组  
  169.     int a[] = {12,15,16,18,23,89,73,29,88,97};  
  170.       
  171.     //调用函数输出遍历数组  
  172.     print(a, 10, '*', false);  
  173.     print(a, 10, '/', true);  
  174.       
  175.     cout << "===== 默认值 ====" << endl;  
  176.       
  177.     //7  
  178.     //可以不用给定是否需要输出中括号 因为已经给定默认值了  
  179.     print(a,10,' ');  
  180.     //另外一次特殊的可以给定  传进参数的话  
  181.     print(a, 10, '*',false);  
  182.       
  183.     //8  
  184.     //没有输入最后一个参数  会默认使用给定的默认值  
  185.     print2(a, 10,'^');  
  186.     //在我输入的时候 不输入分隔符  就会自动用默认值了  
  187. //    print2(a, 10);  
  188.       
  189.       
  190.       
  191.     //9.  
  192.     //print2(a, 10,'');  
  193.    // print2(a, 10);//这样会报错，因为第8个函数也可以只是传2个参数  所以这里就不知道用第8个还是第9个的了  那该怎么办？除了改方法名     用哑元参数  
  194.       
  195.       
  196.     cout << "==== 哑元参数 ====" << endl;  
  197.     //10  
  198.     print2(a, 10);//只传2个参数 那就是使用第8个默认值的函数  
  199.     //如果想要挨个打印   那就传一个哑元参数  
  200.     print2(a,10,3.14f);  
  201.       
  202.     return 0;  
  203. }  

运行结果如下:

[cpp] view plain copy
  1. 12*15*16*18*23*89*73*29*88*97*  
  2. [12/15/16/18/23/89/73/29/88/97/]  
  3. ===== 默认值 ====  
  4. [12 15 16 18 23 89 73 29 88 97 ]  
  5. 12*15*16*18*23*89*73*29*88*97*  
  6. [12^15^16^18^23^89^73^29^88^97^]  
  7. ==== 哑元参数 ====  
  8. [12 15 16 18 23 89 73 29 88 97 ]  
  9. 12151618238973298897  
  10. Program ended with exit code: 0 








++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

1. 静态类相当于一个sealed abstract类,主要的一个优点是写在栈中,安全高速稳定,而且在执行的时候,十分优先。 类可以声明为 static 的，以指示它仅包含静态成员。不能使用 new 关键字创建静态类的实例。 使用静态类来包含不与特定对象关联的方法。例如，创建一组不操作实例数据并且不与代码中的特定对象关联的方法是很常见的要求。您应该使用静态类来包含那些方法。
2. 它们仅包含静态成员。

  
  • 1
  • 2
  • 3

它们不能被实例化。
它们是密封的。
它们不能包含实例构造函数）。
因此创建静态类与创建仅包含静态成员和私有构造函数的类大致一样。私有构造函数阻止类被实例化。
3. 使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员。编译器将保证不会创建此类的实例。
静态类是密封的，因此不可被继承。静态类不能包含构造函数，但仍可声明静态构造函数以分配初始值或设置某个静态状态。
4. 静态类不能有实例构造器。
静态类不能有任何实例成员。 静态类不能使用abstract或sealed修饰符。 静态类默认继承自System.Object根类，不能显式指定任何其他基类。
静态类不能指定任何接口实现。
静态类的成员不能有protected或protected internal访问保护修饰符。


++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


java中的单例模式与静态类

单例模式与静态类（一个类，所有方法为静态方法）是另一个非常有趣的问题，在《Java中有关单例模式的面试问题》博文中露掉了，由于单例模式和静态类都具有良好的访问性，它们之间有许多相似之处，例如，两者可以直接使用而无须创建对象，都可提交唯一实例，在一个非常高的高度上看起来它们都为是用于同样的任务。由于它们具有较多的相似性，面试官常常会问一些类似为神马使用单例模式替换静态方法？你能使用静态类替换单例模式吗？Java中单例模式与静态的区别有那些？等这样的问题，为回答这些问题，记住他们单例模式和静态方法之间基本的区别是非常重要的，前者给你一个Object，后者仅仅提供静态方法，由于对像比方法具有较强的能力，可以指导你神马时候使用单例模式与静态方法。

 
在本文中，我们会了解神马Java中的神马地方使用单例模式，神马时候使用静态类更好，顺便说下，JDK中有几个关于两者的例子，并且这例子非常聪明的，例如java.lang.Math是一个final类，并且其方法为静态方法，另一方面java.lang.Runtime是一个单例的类。对于那些不熟悉单例模式或静态类的人，静态类就是一个Java类，它仅包含静态方法， 一个非常

好静态类的例子就是java.lang.Math，它包


括了许多为不同数据功能实现工具方法，



例如sqrt()，而单例类，在整个应用生命周

期内只有一个实例，例如


java.lang.Runtime。
 
神马时候在Java中使用静态类替换单例
确实存在一些场景，静态类比单例更适合，这个场景中主要的一个例子就是java.lang.Math，它不是单例的，其所有方法都是静态方法，这里我给出几个场景，我觉得使用静态类比单例模式更适合。
1)        如果你的单例不需要维护任何状态，仅仅提供全局访问的方法，这种情况考虑使用静态类，静态方法比单例更快，因为静态的绑定是在编译期就进行的。但是要记住，不建议在静态类中维护状态信息，特别是在并发环境中，若无适当的同步措施而修改多线程并发时，会导致坏的竞态条件。
如果你需要将一些工具方法集中在一起时，你可以选择使用静态方法，但是别的东西，要求单例访问资源时，应该使用单例模式。
 
Java中单例与静态的区别
这是回答关于单例与静态的第二面试问题，如我早些提到过的，它们基本的区别一个表现类，一个表现方法，下面列几条它们之间的区别。
1)        静态类比单例具有更好的性能，因为静态方法在编译期绑定。
2)        再次，它们的区别是override的能力，因Java中的静态方法是不可以覆盖的，这就导致其木有太多的灵活性，另一面，你可通过继承的方式覆盖单例类中定义的方法。
3)        静态类很难模拟，因此难于单例测试，单例更容易模拟，因为也比静态类易于编写单元测试，不论神马单例期望神马，你都可以传递模拟对象，例如构造方法或方法参数。
4)        如果你的需求中需要维护状态信息，则单例比静态类更适合，因为后者在维护状态信息方面是非常可怕的，并导致狡滑的bug。
5)        如果是一个非常重的对象，单例可以懒加载，但是静态类没有这样的优势，并且非常热切的加载。
6)        许多依赖注入的框架对单例都有良好的管理，例如Spring，使用它们非常容易。
两者之间的这些区别，有助于我们在面对一些场景时做出选择，下一节中了解神马时候选择单例而不是静态类。
Java中，选择单例而不是静态类的优点
单例与静态主要的优点是前者比后者更具有面向对象的能力，使用单例，可以通过继承和多态扩展基类，实现接口和更有能力提供不同的实现，如果我们讨论java.lang.Runtime，在Java中它是单例，调用getRuntime()方法，会基于不同的JVM返回不同的实现，但也保证了每个JVM中实有一个实例，如果java.lang.Runtime是一个静态类，不太可能因不同的JVM返回不同的实现。
 
这就是Java中单例与静态类的区别，当你需要一个全OO能力的对象时，选择单例，如果仅仅是将一些静态方法预售，使用静态类。

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



静态类不能有实例构造器。 
静态类不能有任何实例成员。 
静态类不能使用abstract或sealed修饰符。 
静态类默认继承自System.Object根类，不能显式指定任何其他基类。 
静态类不能指定任何接口实现。 
静态类的成员不能有protected或protected internal访问保护修饰符。



+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


当将类的某个数据成员声明为static时，该静态数据成员只能被定义一次，而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本，但静态数据成员只有一个实例存在，与定义了多少类对象无关。静态方法就是与该类相关的，是类的一种行为，而不是与该类的实例对象相关。

静态数据成员的用途之一是统计有多少个对象实际存在。

静态数据成员不能在类中初始化，实际上类定义只是在描述对象的蓝图，在其中指定初值是不允许的。也不能在类的构造函数中初始化该成员，因为静态数据成员为类的各个对象共享，否则每次创建一个类的对象则静态数据成员都要被重新初始化。

静态成员不可在类体内进行赋值，因为它是被所有该类的对象所共享的。你在一个对象里给它赋值，其他对象里的该成员也会发生变化。为了避免混乱，所以不可在类体内进行赋值。

静态成员的值对所有的对象是一样的。静态成员可以被初始化，但只能在类体外进行初始化。

一般形式：
数据类型类名：：静态数据成员名＝初值
注意：不能用参数初始化表对静态成员初始化。一般系统缺省初始为0。

静态成员是类所有的对象的共享的成员，而不是某个对象的成员。它在对象中不占用存储空间，这个属性为整个类所共有，不属于任何一个具体对象。所以静态成员不能在类的内部初始化，比如声明一个学生类，其中一个成员为学生总数，则这个变量就应当声明为静态变量，应该根据实际需求来设置成员变量。

复制代码 代码如下:

#include "iostream"
using namespace std;
class test
{
private:
     int x;
     int y;
public:
     static int num;
     static int Getnum()
     {
          x+=5;   // 这行代码是错误的，静态成员函数不能调用非静态数据成员，要通过类的对象来调用。
          num+=15;
          return num;
     }
};
int test::num = 10;
int main(void)
{
     test a;
     cout<<test::num<<endl;        //10
     test::num = 20;
     cout<<test::num<<endl;        //20
     cout<<test::Getnum()<<endl;   //35
     cout<<a.Getnum()<<endl;       //50
     system("pause");
     return 0;
}

通过上例可知：  x+=5;   // 这行代码是错误的
静态函数成员必须通过对象名来访问非静态数据成员。
另外，静态成员函数在类外实现时候无须加static关键字，否则是错误的。
若在类的体外来实现上述的那个静态成员函数，不能加static关键字，这样写就可以了:
复制代码 代码如下:

     int test::Getnum()
     {
       .........
     }

1、static成员的所有者是类本身和对象，但是多有对象拥有一样的静态成员。从而在定义对象是不能通过构造函数对其进行初始化。

2、静态成员不能在类定义里边初始化，只能在class body外初始化。

3、静态成员仍然遵循public，private，protected访问准则。

4、静态成员函数没有this指针，它不能返回非静态成员，因为除了对象会调用它外，类本身也可以调用。

静态成员函数可以直接访问该类的静态数据和函数成员，而访问非静态数据成员必须通过参数传递的方式得到一个对象名，然后通过对象名来访问。

复制代码 代码如下:

class Myclass
{
private:
        int a,b,c;
        static int Sum;    //声明静态数据成员
public:
        Myclass(int a,int b,int c);
        void GetSum();
};
int Myclass::Sum=0;       //定义并初始化静态数据成员
Myclass::Myclass(int a,int b,int c)
{
        this->a=a;
        this->b=b;
        this->c=c;
        Sum+=a+b+c;
}
void Myclass::GetSum()
{
        cout <<"Sum=" <<Sum <<endl;
}
int main(void)
{
        Myclass me(10,20,30);
        me.GetSum();
        system("pause");
        return 0;
}

由上例可知，非静态成员函数可以任意地访问静态成员函数和静态数据成员。
非静态成员函数Myclass(int a,int b,int c)和GetSum()都访问了静态数据成员Sum。
静态成员函数不能访问非静态成员函数和非静态数据成员。

关于静态成员函数，可以总结为以下几点：

出现在类体外的函数定义不能指定关键字static；

静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；

非静态成员函数可以任意地访问静态成员函数和静态数据成员；

静态成员函数不能访问非静态成员函数和非静态数据成员；

由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；

调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，当同一类的所有对象使用一个量时，对于这个共用的量，可以用静态数据成员变量，这个变量对于同一类的所有的对象都取相同的值。静态成员变量只能被静态成员函数调用。静态成员函数也是由同一类中的所有对象共用。只能调用静态成员变量和静态成员函数。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


  static对象如果出现在类中，那么该对象即使从未被使用到，它也会被构造以及析构。而函数中的static对象，如果该函数从未被调用，这个对象也就绝不会诞生，但是在函数每次被调用时检查对象是否需要诞生。

下面详细说说static的功能以及它的来龙去脉：

static作为编程语言里面一种重要的数据类型，它的地位在面试的过程里也是相当的高。

为什么要引入static

　　函数内部定义的变量，在程序执行到它的定义处时，编译器为它在栈上分配空间，大家知道，函数在栈上分配的空间在此函数执行结束时会释放掉，这样就产生了一个问题: 如果想将函数中此变量的值保存至下一次调用时，如何实现？最容易想到的方法是定义一个全局的变量，但定义为一个全局变量有许多缺点，最明显的缺点是破坏了此变量的访问范围（使得在此函数中定义的变量，不仅仅受此函数控制）。

什么时候用static

　　需要一个数据对象为整个类而非某个对象服务,同时又力求不破坏类的封装性,即要求此成员隐藏在类的内部，对外不可见。

static的内部机制

　　静态数据成员要在程序一开始运行时就必须存在。因为函数在程序运行中被调用，所以静态数据成员不能在任何函数内分配空间和初始化。

　　这样，它的空间分配有三个可能的地方，一是作为类的外部接口的头文件，那里有类声明；二是类定义的内部实现，那里有类的成员函数定义；三是应用程序的main（）函数前的全局数据声明和定义处。

　　静态数据成员要实际地分配空间，故不能在类的声明中定义（只能声明数据成员）。类声明只声明一个类的“尺寸和规格”，并不进行实际的内存分配，所以在类声明中写成定义是错误的。它也不能在头文件中类声明的外部定义，因为那会造成在多个使用该类的源文件中，对其重复定义。

　　static被引入以告知编译器，将变量存储在程序的静态存储区而非栈上空间，静态

　　数据成员按定义出现的先后顺序依次初始化，注意静态成员嵌套时，要保证所嵌套的成员已经初始化了。消除时的顺序是初始化的反顺序。

static的优势

　　可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

应用格式（C++）

　　引用静态数据成员时，采用如下格式：

　　<类名>::<静态成员名>

　　如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。

注意事项

　　(1)类的静态成员函数是属于整个类而非类的对象，所以它没有this指针，这就导致了它仅能访问类的静态数据和静态成员函数。

　　(2)不能将静态成员函数定义为虚函数。(注意：如果在static函数加上virtual关键字就会报出这样子的错误error: Semantic Issue: 'virtual' can only appear on non-static member functions，大家懂了吧！
)

　　(3)由于静态成员声明于类中，操作于其外，所以对其取地址操作，就多少有些特殊，变量地址是指向其数据类型的指针，函数地址类型是一个“nonmember函数指针”。

　　(4)由于静态成员函数没有this指针，所以就差不多等同于nonmember函数，结果就产生了一个意想不到的好处：成为一个callback函数，使得我们得以将C++和C-based X Window系统结合，同时也成功的应用于线程函数身上。

　　(5)static并没有增加程序的时空开销，相反她还缩短了子类对父类静态成员的访问时间，节省了子类的内存空间。

　　(6)静态数据成员在<定义或说明>时前面加关键字static。

　　(7)静态数据成员是静态存储的，所以必须对它进行初始化。

　　(8)静态成员初始化与一般数据成员初始化不同:

　　初始化在类体外进行，而前面不加static，以免与一般静态变量或对象相混淆；

　　初始化时不加该成员的访问权限控制符private，public等；

　　初始化时使用作用域运算符来标明它所属类；

　　所以我们得出静态数据成员初始化的格式：

　　<数据类型><类名>::<静态数据成员名>=<值>

　　(9)为了防止父类的影响，可以在子类定义一个与父类相同的静态变量，以屏蔽父类的影响。这里有一点需要注意：我们说静态成员为父类和子类共享，但我们有重复定义了静态成员，这会不会引起错误呢？不会，我们的编译器采用了一种绝妙的手法：name-mangling 用以生成唯一的标志。在各通信公司的笔试面试中经常出现的考题就是static的作用及功能。

（1）面向对象的static关键字

　　1、静态数据成员

　　在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。

　　//Example 1

　　#include <iostream.h>

　　class Myclass

　　{

　　public:

　　Myclass(int a,int b,int c);

　　void GetSum();

　　private:

　　int a,b,c;

　　static int Sum;//声明静态数据成员

　　};

　　int Myclass::Sum=0;//定义并初始化静态数据成员

　　Myclass::Myclass(int a,int b,int c)

　　{ this->a=a;

　　this->b=b;

　　this->c=c;

　　Sum+=a+b+c;}

　　void Myclass::GetSum()

　　{ cout<<"Sum="<<Sum<<endl;

　　}

　　void main()

　　{ Myclass M(1,2,3);

　　M.GetSum();

　　Myclass N(4,5,6);

　　N.GetSum();

　　M.GetSum();}

　　可以看出，静态数据成员有以下特点：

　　对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；

　　静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；

　　静态数据成员和普通数据成员一样遵从public,protected,private访问规则；

　　因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它.

　　类的静态数据成员有两种访问形式：

　　<类对象名>.<静态数据成员名> 或 <类类型名>::<静态数据成员名>

　　如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ；

　　静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；

　　同全局变量相比，使用静态数据成员有两个优势：

　　静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；

　　可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

　　2、静态成员函数

　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this 是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。

　　//Example 2

　　#include <iostream.h>

　　class Myclass

　　{public:

　　Myclass(int a,int b,int c);

　　static void GetSum();/声明静态成员函数

　　private:

　　int a,b,c;

　　static int Sum;//声明静态数据成员

　　};

　　int Myclass::Sum=0;//定义并初始化静态数据成员

　　Myclass::Myclass(int a,int b,int c)

　　{ this->a=a;

　　this->b=b;

　　this->c=c;

　　Sum+=a+b+c; //非静态成员函数可以访问静态数据成员

　　}

　　void Myclass::GetSum() //静态成员函数的实现

　　{

      // cout<<a<<endl; //错误代码，a是非静态数据成员

　　cout<<"Sum="<<Sum<<endl;

　　}

　　void main()

　　{ Myclass M(1,2,3);

　　M.GetSum();

　　Myclass N(4,5,6);

　　N.GetSum();

　　Myclass::GetSum();

　　}

　　关于静态成员函数，可以总结为以下几点：

　　出现在类体外的函数定义不能指定关键字static；

　　静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；

　　非静态成员函数可以任意地访问静态成员函数和静态数据成员；

　　静态成员函数不能访问非静态成员函数和非静态数据成员；

　　由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；

　　调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：

　　<类名>::<静态成员函数名>（<参数表>）

　　调用类的静态成员函数。

作用

　　static静态变量声明符。在声明它的程序块，子程序块或函数内部有效，值保持，在整个程序期间分配存储器空间，编译器默认值0。

　　是C++中很常用的修饰符，它被用来控制变量的存储方式和可见性

（2）面向过程的static关键字:功能：隐藏作用、值保持。

  1. 隐藏作用。当我们同时编译多个文件时，所有未加static前缀的全局变量和函数都具有全局可见性。如果加了static，就会对其它源文件隐藏。利用这一特性可以在不同的文件中定义同名函数和同名变量，而不必担心命名冲突。Static可以用作函数和变量的前缀，对于函数来讲，static的作用仅限于隐藏，而对于变量，static还有下面两个作用。
  2. 保持变量内容的持久。存储在静态数据区的变量会在程序刚开始运行时就完成初始化，也是唯一的一次初始化。共有两种变量存储在静态存储区：全局变量和static变量，只不过和全局变量比起来，static可以控制变量的可见范围，说到底static还是用来隐藏的。
  3. 默认初始化为0。其实全局变量也具备这一属性，因为全局变量也存储在静态数据区。在静态数据区，内存中所有的字节默认值都是0x00，某些时候这一特点可以减少程序员的工作量。比如初始化一个稀疏矩阵，我们可以一个一个地把所有元素都置0，然后把不是0的几个元素赋值。如果定义成静态的，就省去了一开始置0的操作。再比如要把一个字符数组当字符串来用，但又觉得每次在字符数组末尾加’\ 0’太麻烦。如果把字符串定义成静态的，就省去了这个麻烦，因为那里本来就是’\0’。

总之，首先static的最主要功能是隐藏，其次因为static变量存放在静态存储区，所以它具备持久性和默认值0。

另外，记住c++的一个哲学基础：你不应该为你并不使用的东西付出任何代价。



++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

C++中的static关键字的总结

　　C++的static有两种用法：面向过程程序设计中的static和面向对象程序设计中的static。前者应用于普通变量和函数，不涉及类；后者主要说明static在类中的作用。

1.面向过程设计中的static
1.1静态全局变量
在全局变量前，加上关键字static，该变量就被定义成为一个静态全局变量。我们先举一个静态全局变量的例子，如下：
//Example 1
#include <iostream.h>
void fn();
static int n; //定义静态全局变量
void main()
{
 　　n=20;
 　　cout<<n<<endl;
 　　fn();
}

void fn()
{
　　 n++;
 　　cout<<n<<endl;
}
静态全局变量有以下特点：
• 该变量在全局数据区分配内存；
• 未经初始化的静态全局变量会被程序自动初始化为0（自动变量的值是随机的，除非它被显式初始化）；
• 静态全局变量在声明它的整个文件都是可见的，而在文件之外是不可见的；　

静态变量都在全局数据区分配内存，包括后面将要提到的静态局部变量。对于一个完整的程序，在内存中的分布情况如下图：　
代码区
全局数据区
堆区
栈区
一般程序的由new产生的动态数据存放在堆区，函数内部的自动变量存放在栈区。自动变量一般会随着函数的退出而释放空间，静态数据（即使是函数内部的静态局部变量）也存放在全局数据区。全局数据区的数据并不会因为函数的退出而释放空间。细心的读者可能会发现，Example 1中的代码中将 “static int n; //定义静态全局变量”改为“int n; //定义全局变量”。程序照样正常运行。的确，定义全局变量就可以实现变量在文件中的共享，但定义静态全局变量还有以下好处：
• 静态全局变量不能被其它文件所用；
• 其它文件中可以定义相同名字的变量，不会发生冲突；

您可以将上述示例代码改为如下：
//Example 2
//File1
#include <iostream.h>
void fn();
static int n; //定义静态全局变量
void main()
{
 　　n=20;
 　　cout<<n<<endl;
 　　fn();
}

//File2
#include <iostream.h>
extern int n;
void fn()
{
　　 n++;
 　　cout<<n<<endl;
}
编译并运行Example 2，您就会发现上述代码可以分别通过编译，但运行时出现错误。试着将 “static int n; //定义静态全局变量”改为“int n; //定义全局变量”
再次编译运行程序，细心体会“全局变量”和"静态全局变量"的区别。

1.2.静态局部变量
在局部变量前，加上关键字static，该变量就被定义成为一个静态局部变量。 我们先举一个静态局部变量的例子，如下：
//Example 3
#include <iostream.h>
void fn();
void main()
{
 　　fn();
 　　fn();
 　　fn();
}
void fn()
{
 　　static n=10;
 　　cout<<n<<endl;
　　 n++;
}
通常，在函数体内定义了一个变量，每当程序运行到该语句时都会给该局部变量分配栈内存。但随着程序退出函数体，系统就会收回栈内存，局部变量也相应失效。但有时候我们需要在两次调用之间对变量的值进行保存。通常的想法是定义一个全局变量来实现。但这样一来，变量已经不再属于函数本身了，不再仅受函数的控制，给程序的维护带来不便。
静态局部变量正好可以解决这个问题。静态局部变量保存在全局数据区，而不是保存在栈中，每次的值保持到下一次调用，直到下次赋新值。
静态局部变量有以下特点：
• 该变量在全局数据区分配内存；
• 静态局部变量在程序执行到该对象的声明处时被首次初始化，即以后的函数调用不再进行初始化；
• 静态局部变量一般在声明处初始化，如果没有显式初始化，会被程序自动初始化为0；
• 它始终驻留在全局数据区，直到程序运行结束。但其作用域为局部作用域，当定义它的函数或语句块结束时，其作用域随之结束；

1.3静态函数
　　在函数的返回类型前加上static关键字,函数即被定义为静态函数。静态函数与普通函数不同，它只能在声明它的文件当中可见，不能被其它文件使用。
静态函数的例子：
//Example 4
#include <iostream.h>
static void fn();//声明静态函数
void main()
{
 　　fn();
}
void fn()//定义静态函数
{
 　　int n=10;
 　　cout<<n<<endl;
}
定义静态函数的好处：
• 静态函数不能被其它文件所用；
• 其它文件中可以定义相同名字的函数，不会发生冲突；

 


二、面向对象的static关键字（类中的static关键字）
2.1静态数据成员
在类内数据成员的声明前加上关键字static，该数据成员就是类内的静态数据成员。先举一个静态数据成员的例子。
//Example 5
#include <iostream.h>
class Myclass
{
public:
 　　Myclass(int a,int b,int c);
 　　void GetSum();
private:
 　　int a,b,c;
 　　static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
 　　this->a=a;
 　　this->b=b;
 　　this->c=c;
 　　Sum+=a+b+c;
}

void Myclass::GetSum()
{
 　　cout<<"Sum="<<Sum<<endl;
}

void main()
{
 　　Myclass M(1,2,3);
 　　M.GetSum();
　　 Myclass N(4,5,6);
 　　N.GetSum();
 　　M.GetSum();

}
可以看出，静态数据成员有以下特点：
• 对于非静态数据成员，每个类对象都有自己的拷贝。而静态数据成员被当作是类的成员。无论这个类的对象被定义了多少个，静态数据成员在程序中也只有一份拷贝，由该类型的所有对象共享访问。也就是说，静态数据成员是该类的所有对象所共有的。对该类的多个对象来说，静态数据成员只分配一次内存，供所有对象共用。所以，静态数据成员的值对每个对象都是一样的，它的值可以更新；
• 静态数据成员存储在全局数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义。在Example 5中，语句int Myclass::Sum=0;是定义静态数据成员；
• 静态数据成员和普通数据成员一样遵从public,protected,private访问规则；
• 因为静态数据成员在全局数据区分配内存，属于本类的所有对象共享，所以，它不属于特定的类对象，在没有产生类对象时其作用域就可见，即在没有产生类的实例时，我们就可以操作它；
• 静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为：
＜数据类型＞＜类名＞::＜静态数据成员名＞=＜值＞
• 类的静态数据成员有两种访问形式：
＜类对象名＞.＜静态数据成员名＞ 或 ＜类类型名＞::＜静态数据成员名＞
如果静态数据成员的访问权限允许的话（即public的成员），可在程序中，按上述格式来引用静态数据成员 ；
• 静态数据成员主要用在各个对象都有相同的某项属性的时候。比如对于一个存款类，每个实例的利息都是相同的。所以，应该把利息设为存款类的静态数据成员。这有两个好处，第一，不管定义多少个存款类对象，利息数据成员都共享分配在全局数据区的内存，所以节省存储空间。第二，一旦利息需要改变时，只要改变一次，则所有存款类对象的利息全改变过来了；
• 同全局变量相比，使用静态数据成员有两个优势：
1. 静态数据成员没有进入程序的全局名字空间，因此不存在与程序中其它全局名字冲突的可能性；
2. 可以实现信息隐藏。静态数据成员可以是private成员，而全局变量不能；

2.2静态成员函数
　　与静态数据成员一样，我们也可以创建一个静态成员函数，它为类的全部服务而不是为某一个类的具体对象服务。静态成员函数与静态数据成员一样，都是类的内部实现，属于类定义的一部分。普通的成员函数一般都隐含了一个this指针，this指针指向类的对象本身，因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下，this是缺省的。如函数fn()实际上是this->fn()。但是与普通函数相比，静态成员函数由于不是与任何的对象相联系，因此它不具有this指针。从这个意义上讲，它无法访问属于类对象的非静态数据成员，也无法访问非静态成员函数，它只能调用其余的静态成员函数。下面举个静态成员函数的例子。
//Example 6
#include <iostream.h>
class Myclass
{
public:
 　　Myclass(int a,int b,int c);
 　　static void GetSum();/声明静态成员函数
private:
 　　int a,b,c;
　　 static int Sum;//声明静态数据成员
};
int Myclass::Sum=0;//定义并初始化静态数据成员

Myclass::Myclass(int a,int b,int c)
{
 　　this->a=a;
 　　this->b=b;
 　　this->c=c;
 　　Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
}

void Myclass::GetSum() //静态成员函数的实现
{
　　// cout<<a<<endl; //错误代码，a是非静态数据成员
 　　cout<<"Sum="<<Sum<<endl;
}

void main()
{
 　　Myclass M(1,2,3);
 　　M.GetSum();
 　　Myclass N(4,5,6);
 　　N.GetSum();
 　　Myclass::GetSum();
}
关于静态成员函数，可以总结为以下几点：
• 出现在类体外的函数定义不能指定关键字static；
• 静态成员之间可以相互访问，包括静态成员函数访问静态数据成员和访问静态成员函数；
• 非静态成员函数可以任意地访问静态成员函数和静态数据成员；
• 静态成员函数不能访问非静态成员函数和非静态数据成员；
• 由于没有this指针的额外开销，因此静态成员函数与类的全局函数相比速度上会有少许的增长；
• 调用静态成员函数，可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指针调用静态成员函数，也可以直接使用如下格式：
＜类名＞::＜静态成员函数名＞（＜参数表＞）
调用类的静态成员函数。


+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

C++类中静态变量和静态方法使用介绍


哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

静态成员的提出是为了解决数据共享的问

题。实现共享有许多方法，如：设置全局

性的变量或对象是一种方法。但是，全局

变量或对象是有局限性的。这一章里，我

们主要讲述类的静态成员来实现数据的共

享。




 在C++中，静态成员是属于整个类的而不

是某个对象，静态成员变量只存储一份供

所有对象共用。所以在所有对象中都可以

共享它。使用静态成员变量实现多个对象

之间的数据共享不会破坏隐藏的原则，保

证了安全性还可以节省内存。

哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈哈

++++++++++++++++++++++++++++++++

在C++中，静态成员是属于整个类的而不是某个对象，静态成员变量只存储一份供所有对象共用。所以在所有对象中都可以共享它。使用静态成员变量实现多个对象之间的数据共享不会破坏隐藏的原则，保证了安全性还可以节省内存。

静态成员的定义或声明要加个关键static。静态成员可以通过双冒号来使用即<类名>::<静态成员名>。

 

在C++中类的静态成员变量和静态成员函数是个容易出错的地方，本文先通过几个例子来总结静态成员变量和成员函数使用规则，再给出一个实例来加深印象。希望阅读本文可以使读者对类的静态成员变量和成员函数有更为深刻的认识。

 

第一个例子，通过类名调用静态成员函数和非静态成员函数

[cpp] view plain copy
  1. class Point  
  2. {  
  3. public:   
  4.     void init()  
  5.     {    
  6.     }  
  7.     static void output()  
  8.     {  
  9.     }  
  10. };  
  11. void main()  
  12. {  
  13.     Point::init();  
  14.     Point::output();  
  15. }  

编译出错：error C2352: 'Point::init' : illegal call of non-static member function

结论1：不能通过类名来调用类的非静态成员函数。

 

第二个例子，通过类的对象调用静态成员函数和非静态成员函数

将上例的main()改为：

[cpp] view plain copy
  1. void main()  
  2. {  
  3.     Point pt;  
  4.     pt.init();  
  5.     pt.output();  
  6. }  

编译通过。

结论2：类的对象可以使用静态成员函数和非静态成员函数。

 

第三个例子，在类的静态成员函数中使用类的非静态成员

[cpp] view plain copy
  1. #include <stdio.h>  
  2. class Point  
  3. {  
  4. public:   
  5.     void init()  
  6.     {    
  7.     }  
  8.     static void output()  
  9.     {  
  10.         printf("%d\n", m_x);  
  11.     }  
  12. private:  
  13.     int m_x;  
  14. };  
  15. void main()  
  16. {  
  17.     Point pt;  
  18.     pt.output();  
  19. }  

编译出错：error C2597: illegal reference to data member 'Point::m_x' in a static member function

因为静态成员函数属于整个类，在类实例化对象之前就已经分配空间了，而类的非静态成员必须在类实例化对象后才有内存空间，所以这个调用就出错了，就好比没有声明一个变量却提前使用它一样。

结论3：静态成员函数中不能引用非静态成员。

 

第四个例子，在类的非静态成员函数中使用类的静态成员

[cpp] view plain copy
  1. class Point  
  2. {  
  3. public:   
  4.     void init()  
  5.     {    
  6.         output();  
  7.     }  
  8.     static void output()  
  9.     {  
  10.     }  
  11. };  
  12. void main()  
  13. {  
  14.     Point pt;  
  15.     pt.output();  
  16. }  

编译通过。

结论4：类的非静态成员函数可以调用用静态成员函数，但反之不能。

 

第五个例子，使用类的静态成员变量

[cpp] view plain copy
  1. #include <stdio.h>  
  2. class Point  
  3. {  
  4. public:   
  5.     Point()  
  6.     {    
  7.         m_nPointCount++;  
  8.     }  
  9.     ~Point()  
  10.     {  
  11.         m_nPointCount--;  
  12.     }  
  13.     static void output()  
  14.     {  
  15.         printf("%d\n", m_nPointCount);  
  16.     }  
  17. private:  
  18.     static int m_nPointCount;  
  19. };  
  20. void main()  
  21. {  
  22.     Point pt;  
  23.     pt.output();  
  24. }  

按Ctrl+F7编译无错误，按F7生成EXE程序时报链接错误

error LNK2001: unresolved external symbol "private: static int Point::m_nPointCount" (?m_nPointCount@Point@@0HA)

这是因为类的静态成员变量在使用前必须先初始化。

在main()函数前加上int Point::m_nPointCount = 0;

再编译链接无错误，运行程序将输出1。

结论5：类的静态成员变量必须先初始化再使用。

 

结合上面的五个例子，对类的静态成员变量和成员函数作个总结：

一。静态成员函数中不能调用非静态成员。

二。非静态成员函数中可以调用静态成员。因为静态成员属于类本身，在类的对象产生之前就已经存在了，所以在非静态成员函数中是可以调用静态成员的。

三。静态成员变量使用前必须先初始化(如int MyClass::m_nNumber = 0;)，否则会在linker时出错。

 

再给一个利用类的静态成员变量和函数的例子以加深理解，这个例子建立一个学生类，每个学生类的对象将组成一个双向链表，用一个静态成员变量记录这个双向链表的表头，一个静态成员函数输出这个双向链表。

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include <string.h>  
  3. const int MAX_NAME_SIZE = 30;    
  4.   
  5. class Student    
  6. {    
  7. public:    
  8.     Student(char *pszName);  
  9.     ~Student();  
  10. public:  
  11.     static void PrintfAllStudents();  
  12. private:    
  13.     char    m_name[MAX_NAME_SIZE];    
  14.     Student *next;  
  15.     Student *prev;  
  16.     static Student *m_head;  
  17. };    
  18.   
  19. Student::Student(char *pszName)  
  20. {    
  21.     strcpy(this->m_name, pszName);  
  22.   
  23.     //建立双向链表，新数据从链表头部插入。  
  24.     this->next = m_head;  
  25.     this->prev = NULL;  
  26.     if (m_head != NULL)  
  27.         m_head->prev = this;  
  28.     m_head = this;    
  29. }    
  30.   
  31. Student::~Student ()//析构过程就是节点的脱离过程    
  32. {    
  33.     if (this == m_head) //该节点就是头节点。  
  34.     {  
  35.         m_head = this->next;  
  36.     }  
  37.     else  
  38.     {  
  39.         this->prev->next = this->next;  
  40.         this->next->prev = this->prev;  
  41.     }  
  42. }    
  43.   
  44. void Student::PrintfAllStudents()  
  45. {  
  46.     for (Student *p = m_head; p != NULL; p = p->next)  
  47.         printf("%s\n", p->m_name);  
  48. }  
  49.   
  50. Student* Student::m_head = NULL;    
  51.   
  52. void main()    
  53. {     
  54.     Student studentA("AAA");  
  55.     Student studentB("BBB");  
  56.     Student studentC("CCC");  
  57.     Student studentD("DDD");  
  58.     Student student("MoreWindows");  
  59.     Student::PrintfAllStudents();  
  60. }  

程序将输出：

当然在本例还可以增加个静态成员变量来表示链表中学生个数，如果读者有兴趣，就将这个作为小练习吧。


++++++++++++++++++++++++++++++++

静态成员的定义或声明要加个关键static。静态成员可以通过双冒号来使用即<类名>::<静态成员名>。


　　静态数据成员

　　在类中，静态成员可以实现多个对象之间的数据共享，并且使用静态数据成员还不会破坏隐藏的原则，即保证了安全性。因此，静态成员是类的所有对象中共享的成员，而不是某个对象的成员。

　　使用静态数据成员可以节省内存，因为它是所有对象所公有的，因此，对多个对象来说，静态数据成员只存储一处，供所有对象共用。静态数据成员的值对每个对象都是一样，但它的值是可以更新的。只要对静态数据成员的值更新一次，保证所有对象存取更新后的相同的值，这样可以提高时间效率。

　　静态数据成员的使用方法和注意事项如下：

　　1、静态数据成员在定义或说明时前面加关键字static。//静态变量的定义

　　2、静态成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式如下：

　　　　<数据类型><类名>::<静态数据成员名>=<值>  //静态变量的初始化

　　这表明：

         (1) 初始化在类体外进行，而前面不加


static，（这点需要注意）以免与一般静态


变量或对象相混淆。

　　(2) 初始化时不加该成员的访问权限控制符private，public等。

　　(3) 初始化时使用作用域运算符来标明它所属类，因此，静态数据成员是类的成

员，而不是对象的成员。

　　3、静态数据成员是静态存储的，它是静态生存期，必须对它进行初始化。

　　4、引用静态数据成员时，采用如下格式：

　　　<类名>::<静态成员名>   //静态变量的使用方式

　　如果静态数据成员的访问权限允许的话(即public的成员)，可在程序中，按上述格式来引用静态数据成员。

　　下面举一例子，说明静态数据成员的应用：

复制代码 
 1 class StaticTest
 2 {
 3 public:
 4     StaticTest(int a, int b, int c);
 5     void GetNumber();
 6     void GetSum();
 7     static void f1(StaticTest &s);
 8 private:
 9     int A, B, C;
10     static int Sum;
11 };
12 
13 
14 
15 #include "StaticTest.h"
16 #include <iostream>
17 using namespace std;
18 
19 int StaticTest::Sum = 0;//静态成员在此初始化
20 
21 StaticTest::StaticTest(int a, int b, int c)
22 {
23     A = a;
24     B = b;
25     C = c;
26     Sum += A + B + C;
27 }
28 
29 void StaticTest::GetNumber()
30 {
31     cout << "Number = " << endl;
32 }
33 
34 void StaticTest::GetSum()
35 {
36     cout << "Sum = " << Sum <<endl;
37 }
38 
39 void StaticTest::f1(StaticTest &s)
40 {
41     
42     cout << s.A << endl;//静态方法不能直接调用一般

成员，可以通过对象引用实现调用
43     cout << Sum <<endl;
44 }
45 
46 #include "StaticTest.h"
47 #include <stdlib.h>
48 
49 
50 int main(void)
51 {
52     StaticTest M(3, 7, 10), N(14, 9, 11);
53     M.GetNumber();
54     N.GetSum();
55     M.GetNumber();
56     N.GetSum();
57     StaticTest::f1(M);
58     system("pause");
59     return 0;
60 }
复制代码

 

注意，static成员的初始化要在实现中进行，不能在头文件进行。

从输出结果可以看到Sum的值对M对象和对N对象都是相等的。这是因为在初始化M对象时，将M对象的三个int型数据成员的值求和后赋给了Sum，于是Sum保存了该值。在初始化N对象时，对将N对象的三个int型数据成员的值求和后又加到Sum已有的值上，于是Sum将保存另后的值。所以，不论是通过对象M还是通过对象N来引用的值都是一样的，即为54，s.A=3。

静态成员函数

　　静态成员函数和静态数据成员一样，它们都属于类的静态成员，它们都不是对象成员。因此，对静态成员的引用不需要用对象名。

　　在静态成员函数的实现中不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员（这点非常重要）。如果静态成员函数中要引用非静态成员时，可通过对象来引用。从中可看出，调用静态成员函数使用如下格式：<类名>::<静态成员函数名>(<参数表>);

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

静态方法和实例方法的访问权限表
 静态成员变量静态方法实例成员变量实例方法
静态方法直接访问直接访问不可直接访问不可直接访问
实例方法直接访问直接访问直接访问直接访问

 

 

 

 



++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++


C++静态类

原创 2015年12月19日 10:47:31 

1. 静态类相当于一个sealed abstract类,主要的一个优点是写在栈中,安全高速稳定,而且在执行的时候,十分优先。 类可以声明为 static 的，以指示它仅包含静态成员。不能使用 new 关键字创建静态类的实例。 使用静态类来包含不与特定对象关联的方法。例如，创建一组不操作实例数据并且不与代码中的特定对象关联的方法是很常见的要求。您应该使用静态类来包含那些方法。
2. 它们仅包含静态成员。

  
  • 1
  • 2
  • 3

它们不能被实例化。
它们是密封的。
它们不能包含实例构造函数）。
因此创建静态类与创建仅包含静态成员和私有构造函数的类大致一样。私有构造函数阻止类被实例化。
3. 使用静态类的优点在于，编译器能够执行检查以确保不致偶然地添加实例成员。编译器将保证不会创建此类的实例。
静态类是密封的，因此不可被继承。静态类不能包含构造函数，但仍可声明静态构造函数以分配初始值或设置某个静态状态。
4. 静态类不能有实例构造器。
静态类不能有任何实例成员。 静态类不能使用abstract或sealed修饰符。 静态类默认继承自System.Object根类，不能显式指定任何其他基类。
静态类不能指定任何接口实现。
静态类的成员不能有protected或protected internal访问保护修饰符。




+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

BBBBBBBBBBBBBBBBBB抽象类

A是抽象类，B是A的子类


       A aa2 =null;  //可以定义一个抽象类的引用

       aa2=new B(); //将子类对象地址赋给抽象类的引用


       aa2.f();  //用抽象类的方法访问子类的方法 .这就是多态


+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++



CCCCCCCCCCCCCCCCCCCCC+++SSL服务协议


DDDDDDDDDDDDDDDDD  共享变量




EEEEEEEEEEEEEEEEEEEEEEEE封装+++继承+++多态



+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

回调函数

（1）概念：回调函数，顾名思义，就是使用者自己定义一个函数，使用者自己实现这个函数的程序内容，然后把这个函数作为参数传入别人（或系统）的函数中，由别人（或系统）的函数在运行时来调用的函数。函数是你实现的，但由别人（或系统）的函数在运行时通过参数传递的方式调用，这就是所谓的回调函数。简单来说，就是由别人的函数运行期间来回调你实现的函数。

（2）标准Hello World程序：

int main(int argc,char* argv[])
{
    printf("Hello World!\n");
    return 0;
}

      将它修改成函数回调样式：

复制代码 
//定义回调函数
void PrintfText() 
{
    printf("Hello World!\n");
}

//定义实现回调函数的"调用函数"
void CallPrintfText(void (*callfuct)())
{
    callfuct();
}

//在main函数中实现函数回调
int main(int argc,char* argv[])
{
    CallPrintfText(PrintfText);
    return 0;
}
复制代码

      修改成带参的回调样式：

复制代码 
//定义带参回调函数
void PrintfText(char* s) 
{
    printf(s);
}

//定义实现带参回调函数的"调用函数"
void CallPrintfText(void (*callfuct)(char*),char* s)
{
    callfuct(s);
}

//在main函数中实现带参的函数回调
int main(int argc,char* argv[])
{
    CallPrintfText(PrintfText,"Hello World!\n");
    return 0;
}
复制代码
      至此，对回调函数应该有了一个大致的了解。


lusic01
关注
freemarker总结
01-04
JAVA模版引擎Freemarker常用标签(一) 1. if指令 这是一个典型的分支控制指令,该指令的作用完全类似于Java语言中的if,if指令的语法格式如下: <#if condition>... <#elseif condition>... <#elseif condition>......
freemarker使用例子.txt
10-27
${repeat("What",3)} // WhatWhatWhat ${repeat(repeat("x",2),3)+repeat("What",4)?upper_case} // xxxxxWHATWHATWHATWHAT ``` **解析：** - `repeat("What",3)` 重复字符串 "What" 三次。 - `repeat("x",2)` 重复...
boost之signal的使用
风声的专栏
03-24 1743
文章目录简介代码模板实现：测试代码运行结果 简介 boost是C++的一个扩展库，被称为C++准标准库，里面的组件很丰富，并且引用方便，85%的组件只需要引用头文件即可使用。 并且在嵌入式系统也可以很方便的使用，这里介绍一下signal的使用，有点类似Qt里的信号槽。 可以接收静态函数、类成员函数、labmda表达式。 下面这个是使用signal封装的一个事件注册处理模板，使用起来还是很方便的。 ...
whatwhatwhat
lusic01的专栏
12-04 306
1111111111111111111111111111111111111111111111111111111111111111111 QMetaObject之invokeMethod 点滴记录 2010-10-18 16:53 起源 C++ GUI Qt4 编程 一书多线程部分提到invokeMethod的用法 QMetaObject::invokeMeth
freemarker语法
YHC
06-06 1146
转至:http://blog.csdn.net/hafsky/article/details/5343140freemarker语法一、常用语法 EG.一个对象BOOK 1、输出 $...{book.name} 2、空值判断：$...{book.name?if_exists },                        $...{book.name?default(‘xxx’)}//默认值x
java freemark_Freemarker详解
weixin_28769989的博客
02-16 1585
Yeah.Test pageTest pageBlah blah...Import语法类似于java里的import,它导入文件，然后就可以在当前文件里使用被导入文件里的宏组件用例假设mylib.ftl里定义了宏copyright那么我们在其他模板页面里可以这样使用"my"在freemarker里被称作namespacecompress语法 ...#compress>用来压缩空白空间和空白的...
freemarker 标签的一些用法
羽渡尘的博客
12-04 4175
freemarker 标签的一些用法
FreeMarker学习（三）：模板
weixin_33728268的博客
09-07 113
2019独角兽企业重金招聘Python工程师标准>>> ...
freemarker 模板
weixin_34092455的博客
05-16 139
1 整体结构 模板（FTL 编程）是由例如以下部分混合而成的： Text 文本：文本会照着原样来输出。 Interpolation 插值：这部分的输出会被计算的值来替换。插值由${和}所分隔（或者#{和}。这样的风格已经不建议再使用了）。 FTL tags 标签：FTL 标签和 HTML 标签非常相似，可是它们却是给 FreeMarker 的指示，并且不会打印在输出内容中...
freeMarker学习(二)
钟渊博客
09-16 1765
一、数值和类型 1.1类型的概述： 数值中非常重要的一个概念就是类型。 比方说， 变量 user 的类型是字符串，lotteryNumbers 的类型是序列。 数值的类型非常重要，因为它决定了这些数值可以在 哪里使用的最大限度。 比如${user/2}就是错误的，但是${cargo.weight/2}就能计算出结果 20，除法仅对数字值有效，而不能作用于字符串。 仅当 cargo 是一个
freemarker的使用，转自http://blog.sina.com.cn/s/blog_64c505480100sxuh.html
靖凡的博客
08-25 505
FreeMarker （一）  (2011-08-16 16:28:53) 标签：  杂谈 分类： 学习 1、  模板 + 数据模型 = 输出 2、  MVC模式：Model-View-Controller的缩写，中文翻译为"模型-视图-控制器"。 3、  哈希表通过可查找的名称来访问存储的其他空间 4、  用数组
Freemarker模板语言：Hashes与Sequences操作详解
${repeat("What", 3)} WhatWhatWhat ${repeat(repeat("x", 2), 3) + repeat("What", 4)?upper_case} ``` 此例中，"What"被重复三次，而"x"重复两次后再次重复三次，最后整个字符串都被转换为大写。 FreeMarker的...
基于STM32F103的步进电机S型加减速控制算法详解及应用
07-26
内容概要：本文深入探讨了STM32F103芯片用于步进电机S型加减速控制的具体实现方法。首先介绍了定时器TIM3的初始化配置，这是实现精确脉冲控制的基础。接着详细解析了S型曲线生成函数，该函数将加速段分为两个部分进行处理，分别采用二次函数和线性加二次项组合来模拟S型曲线的不同阶段。文中还展示了中断服务函数中的状态机设计，通过改变定时器的自动重装载寄存器（ARR）值实现了不同运行阶段的速度调节。此外，文章提到了一些调参技巧，如合理设置最大加速度、选择合适的总步数等，并讨论了硬件PWM的应用及其局限性。最后，简述了一个简单的运动规划器，它能够确保多段连续运动之间的平滑过渡。 适合人群：对嵌入式系统有一定了解并希望深入了解步进电机控制机制的研发人员和技术爱好者。 使用场景及目标：适用于需要精细控制步进电机启动停止过程的应用场合，如数控机床(CNC)、3D打印机等领域。目的是减少机械冲击，提高设备使用寿命和加工精度。 其他说明：文中提供的完整工程代码可以帮助读者更好地理解和实践相关理论知识。同时提醒读者关注某些关键参数的选择，以确保最佳性能表现。
材料加工领域ANSYS Workbench瞬态热分析激光熔覆案例：热源加载与APDL代码应用
07-26
内容概要：本文介绍了如何使用ANSYS Workbench进行瞬态热分析，特别是针对激光熔覆的应用。主要内容包括热源加载方法及其APDL代码实现，以及如何输出节点坐标和温度值。文中详细讲解了从几何建模到热源定义，再到最终结果输出的具体步骤和技术细节。通过这些步骤，可以有效地模拟激光熔覆过程中的温度变化，为工艺优化提供了重要的参考。 适合人群：对材料加工领域的激光熔覆技术和有限元分析感兴趣的工程技术人员、研究人员及高校师生。 使用场景及目标：适用于需要深入了解激光熔覆过程中温度场变化的研究项目，旨在提高对激光熔覆工艺的理解并优化相关工艺参数。 其他说明：本文不仅提供了详细的理论解释，还附带了具体的APDL代码示例，方便读者直接应用于实际工作中。此外，鼓励读者在实践中不断探索和完善，以适应不同的应用场景。
STM32项目集锦：锅炉控制器AD采集与通信实践、无刷电调设计创新、测量板多功能应用 实用版
最新发布
07-26
三个基于STM32的项目——锅炉控制器、无刷电调和测量板的设计与实现。每个项目均提供了完整的原理图、PCB布局和源代码。锅炉控制器项目涵盖了热电偶AD采集、Modbus通信、IIC和SPI接口的应用；无刷电调项目重点在于电机的精确速度和位置控制，利用PWM功能并通过IIC/SPI接口实现智能控制；测量板项目则实现了电压和温度采样、OLED显示及温度超限报警功能。这些项目不仅展示了STM32的强大功能和灵活性，也为学习者提供了宝贵的学习资源。 适合人群：嵌入式系统开发者、硬件工程师、电子爱好者及高校相关专业学生。 使用场景及目标：① 学习STM32在工业控制、电机驱动和环境监测中的具体应用；② 掌握从硬件设计到软件编程的全流程开发技能；③ 提升对复杂系统架构的理解和优化能力。 其他说明：文中提供的详尽资料有助于读者快速上手STM32开发，理解其内部工作机制，并应用于实际工程项目中。
电力电子技术：逆变技术Matlab模型图（电压型单相半桥全桥逆变电路与电流型三相逆变电路） 高级版
07-26
利用Matlab进行电力电子技术中不同类型的逆变电路建模及其波形分析的方法。具体涵盖了电压型单相半桥逆变电路、电压型单相全桥逆变电路以及电流型三相逆变电路的建模过程。对于每种电路，文中不仅提供了具体的Matlab/Simulink代码片段，还深入探讨了关键参数的选择依据，如死区时间、调制指数、移相角度、LC滤波器参数等，并强调了这些参数对最终波形质量的影响。此外，作者分享了一些实际操作中的经验技巧，比如如何避免波形畸变、优化动态响应特性、确保电流波形的正弦性和相位关系等。 适合人群：从事电力电子技术研发的专业人士，尤其是那些希望深入了解逆变技术并掌握Matlab仿真的工程师和技术爱好者。 使用场景及目标：①为研究人员提供一套完整的逆变电路仿真解决方案；②帮助工程师快速搭建实验环境，验证理论假设；③降低实际硬件测试的风险和成本。 阅读建议：读者可以跟随文中的步骤逐步尝试构建自己的逆变电路模型，在实践中体会各个参数的作用机制，并对比不同配置下的性能差异。同时，借助提供的FFT分析工具，能够更加直观地评估信号的质量。
langchain4j-ollama-spring-boot-starter-0.29.0.jar中文文档.zip
07-26
1、压缩文件中包含： 中文文档、jar包下载地址、Maven依赖、Gradle依赖、源代码下载地址。 2、使用方法： 解压最外层zip，再解压其中的zip包，双击 【index.html】 文件，即可用浏览器打开、进行查看。 3、特殊说明： （1）本文档为人性化翻译，精心制作，请放心使用； （2）只翻译了该翻译的内容，如：注释、说明、描述、用法讲解 等； （3）不该翻译的内容保持原样，如：类名、方法名、包名、类型、关键字、代码 等。 4、温馨提示： （1）为了防止解压后路径太长导致浏览器无法打开，推荐在解压时选择“解压到当前文件夹”（放心，自带文件夹，文件不会散落一地）； （2）有时，一套Java组件会有多个jar，所以在下载前，请仔细阅读本篇描述，以确保这就是你需要的文件。 5、本文件关键字： jar中文文档.zip,java,jar包,Maven,第三方jar包,组件,开源组件,第三方组件,Gradle,中文API文档,手册,开发手册,使用手册,参考手册。
基于PMSM的改进神经网络自抗扰控制与经典ADRC的Simulink仿真对比研究：无模型控制下的三闭环控制策略与效果评估
07-26
内容概要：本文详细探讨了基于永磁同步电机（PMSM）的自抗扰控制（ADRC）与改进的神经网络自抗扰控制在Simulink中的仿真模型对比。首先介绍了PMSM的特点及其广泛的应用背景，接着阐述了自抗扰控制作为无模型控制方法的优势，特别是在不需要精确模型的情况下仍能有效控制PMSM。文中还提到，通过Simulink构建的三闭环控制策略（电流环、速度环和位置环），实现了对PMSM的精准控制。随后，文章重点讲解了改进的神经网络自抗扰控制，强调了其在处理复杂非线性问题方面的优势，并展示了如何在每个闭环中融入神经网络控制策略。最后，通过对两种控制方式的仿真对比，验证了改进的神经网络自抗扰控制在控制效果、响应速度和稳定性等方面均优于传统自抗扰控制。 适合人群：从事电机控制领域的研究人员和技术人员，尤其是对自抗扰控制和神经网络控制感兴趣的读者。 使用场景及目标：适用于希望深入了解PMSM控制技术的研究人员和技术人员，旨在帮助他们掌握最新的控制技术和工具，提升实际项目中的控制性能。 其他说明：文章附带了相关理论参考资料，如《现代控制系统》、《自抗扰控制原理与应用》、《神经网络控制》，为读者提供了进一步学习的方向。
无刷直流电机无传感器控制：基于容积卡尔曼滤波的转速与转子位置估计及Simulink建模 精华版
07-26
无刷直流电机（BLDC）无传感器控制的一种高效解决方案——基于容积卡尔曼滤波（CKF）的转速和转子位置估计方法。文中首先阐述了无传感器控制的意义及其优势，随后深入探讨了系统的实现框架，包括电机本体模型和CKF观测器两大部分。重点讲解了状态方程的非线性处理、协方差矩阵的处理方式以及容积点生成的具体实现。此外，还提到了在Simulink中进行闭环测试时遇到的问题及解决方案，如采样频率与数值积分方法的配合问题，并展示了通过对比实验验证CKF观测器性能优越性的过程。最后，讨论了一些常见的实现细节和技术挑战，如角度归一化处理、抗饱和处理和启动策略等。 适用人群：从事电机控制系统研究与开发的技术人员，尤其是对无刷直流电机无传感器控制感兴趣的工程师。 使用场景及目标：适用于希望深入了解并掌握无刷直流电机无传感器控制技术的研究人员和工程师。目标是在提高转速和转子位置估计精度的同时降低硬件成本，增强系统的鲁棒性和可靠性。 其他说明：文中提供了详细的理论推导、代码实现和实验数据，有助于读者全面理解和实践这一先进技术。同时，文中提到的一些优化技巧对于实际工程项目也有重要参考价值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值