精华内容
下载资源
问答
  • matlab——std函数用法

    万次阅读 多人点赞 2018-01-24 22:49:55
    y=std(x) 算出x的标准偏差。 x可以是vector或者一个matrix矩阵。 若x是vector,则y是算x的标准偏差。 若x是matrix,则y是个vector,存放的是算每一列/行的标准偏差。 std (x, flag,dim) fla表示标注公差时是要除以n...
    y=std(x) 算出x的标准偏差。 x可以是vector或者一个matrix矩阵。
     
    若x是vector,则y是算x的标准偏差。
    若x是matrix,则y是个vector,存放的是算每一列/行的标准偏差。  std (x, flag,dim)
    fla表示标注公差时是要除以n还是n-1
    flag==0.........是除以n-1
    flag==1.........是除以n
    dim表示维数
    dim==1..........是按照列分
    dim==2..........是按照行分 若是三维的矩阵,dim==3就按照第三维来分数据
    
    默认std格式是std(x,0,1);
    
     >>x=[ 1 2 3 4; 4 5 6 1 ]
     >>std(x)
    ans =
        2.1213    2.1213    2.1213    2.1213
    
    >> std(x,1)
    ans =
        1.5000    1.5000    1.5000    1.5000
    
     >> std(x,0,2)
    ans =
        1.2910
        2.1602
    
    >> std(x,1,2)
    ans =
        1.1180
        1.8708
    
    展开全文
  • C++11的std::ref、std::cref源码解析

    万次阅读 多人点赞 2021-05-09 11:13:21
    C++11的std::ref、std::cref源码解析1、源码准备2、std::ref和std::cref的作用3、std::ref相关源码解析3.1、std::ref解析3.1、std::reference_wrapper解析3.3、std::remove_cv解析3.4、std::_Reference_wrapper_base...

    1、源码准备

    本文是基于gcc-4.9.0的源代码进行分析,std::ref和std::cref是C++11才加入标准的,所以低版本的gcc源码是没有这两个的,建议选择4.9.0或更新的版本去学习,不同版本的gcc源码差异应该不小,但是原理和设计思想的一样的,下面给出源码下载地址
    http://ftp.gnu.org/gnu/gcc

    2、std::ref和std::cref的作用

    C++本身就有引用(&),那为什么C++11又引入了std::ref(或者std::cref)呢?
    答案很简单,这主要是考虑函数式编程(如std::bind)在使用时,是对参数直接拷贝,而不是引用。下面举一个简单的例子大家就明白了。

    #include <functional>
    #include <iostream>
     
    void fun(int& n1, int& n2, const int& n3)
    {
        std::cout << "In function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
        ++n1; // increments the copy of n1 stored in the function object
        ++n2; // increments the main()'s n2
        // ++n3; // compile error
        std::cout << "In function end: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
    }
     
    int main()
    {
        int n1 = 1, n2 = 1, n3 = 1;
        std::function<void()> fff = std::bind(f, n1, std::ref(n2), std::cref(n3));
        std::cout << "Before function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
        fff();
        std::cout << "After function: " << n1 << ' ' << n2 << ' ' << n3 << '\n';
    }
    

    运行结果:

    Before function: 1 1 1
    In function: 1 1 1
    In function end: 2 2 1
    After function: 1 2 1
    

    从上面的例子中可以看到,执行完fff,n1的值仍然是1,n2的值已经改变,这说明std::bind使用的是参数的拷贝而不是引用,这也就是为什么C++11要引入std::refstd::cref的原因了,接下来分析std::ref的实现(std::cref不作分析,因为std::crefstd::ref唯一的差别只是引用变成了const而已)

    3、std::ref相关源码解析

    3.1、std::ref解析

    std::ref位于libstdc++-v3\include\std\functional

    template<typename _Tp>
    inline reference_wrapper<_Tp> ref(_Tp& __t) noexcept
    { return reference_wrapper<_Tp>(__t); }
    
    template<typename _Tp>
    void ref(const _Tp&&) = delete;
    
    template<typename _Tp>
    inline reference_wrapper<_Tp> ref(reference_wrapper<_Tp> __t) noexcept
    { return ref(__t.get()); }
    

    从源代码中可以看出以下几点信息:

    1. std::ref是一个模板函数,返回值是模板类std::reference_wrapper
    2. 从第二个函数可以看到,std::ref不允许传递右值引用参数,即无法包装右值引用传递的值
    3. std::ref的传入参数可以是一个普通的引用,也可以是另外一个std::reference_wrapper对象,接下来分析std::reference_wrapper的实现

    3.1、std::reference_wrapper解析

    std::reference_wrapper位于libstdc++-v3\include\std\functional

    template<typename _Tp>
    class reference_wrapper : public _Reference_wrapper_base<typename remove_cv<_Tp>::type>
    {
        _Tp* _M_data;
    
    public:
        typedef _Tp type;
    
        reference_wrapper(_Tp& __indata) noexcept
            :_M_data(std::__addressof(__indata))
        {
        }
    
        reference_wrapper(_Tp&&) = delete;
    
        reference_wrapper(const reference_wrapper<_Tp>& __inref) noexcept
            :_M_data(__inref._M_data)
        {
        }
    
        reference_wrapper& operator=(const reference_wrapper<_Tp>& __inref) noexcept
        {
            _M_data = __inref._M_data;
            return *this;
        }
    
        operator _Tp&() const noexcept
        { return this->get(); }
    
        _Tp& get() const noexcept
        { return *_M_data; }
    
        template<typename... _Args>
        typename result_of<_Tp&(_Args&&...)>::type
        operator()(_Args&&... __args) const
        {
            return __invoke(get(), std::forward<_Args>(__args)...);
        }
    };
    

    从源代码中可以看出以下几点信息:

    1. 该类继承于std::_Reference_wrapper_base
    2. 有一个类成员_M_data,类型为所引用类型的指针
    3. 第一个构造函数通过调用std::__addressof函数,获得了指向引用参数的指针,并赋值给了_M_data(这也是为什么不支持右值引用的原因,因为取不到对应的地址),至于这里为什么要使用std::__addressof大家可以看一下这篇文章《C++11的std::addressof源码解析》,里面有详细介绍,这里就不重复叙述了
    4. 拷贝构造函数和赋值函数就只是简单地将_M_data的值进行传递而已,没有什么特殊操作
    5. 其余方法就是为了让std::reference_wrapper展现出和普通的引用一样的效果而进行的运算符重载啥的,这里就不赘述了,实现比较简单,大家可以自己看一看具体的代码

    3.3、std::remove_cv解析

    std::remove_cv位于libstdc++-v3\include\std\type_traits

    分析std::_Reference_wrapper_base之前先看一下std::remove_cv的实现:
    其实从std::remove_cv存在于type_traits文件这一点就可以大致推断出,std::remove_cv使用了模板元技术,模板元的主要思想为:利用模板特化机制实现编译期条件选择结构,利用递归模板实现编译期循环结构,模板元程序则由编译器在编译器解释运行,但是其也有明显的优缺点,优点是运行时速度极快,缺点是程序很难看懂,容易劝退初学者,这里不对其做深入分析,知道是这样一个东西就行,有兴趣的可以去查阅专业的C++书籍去了解其中的奥秘
    源代码如下,作用是将模板_Tpconstvoaltile属性分离,这样的话使用::value就可以得到没有const、volatile的类型了

    /// remove_const
    template<typename _Tp>
    struct remove_const
    { typedef _Tp    type; };
    
    template<typename _Tp>
    struct remove_const<_Tp const>
    { typedef _Tp    type; };
    
    /// remove_volatile
    template<typename _Tp>
    struct remove_volatile
    { typedef _Tp    type; };
    
    template<typename _Tp>
    struct remove_volatile<_Tp volatile>
    { typedef _Tp    type; };
    
    /// remove_cv
    template<typename _Tp>
    struct remove_cv
    {
      typedef typename
      remove_const<typename remove_volatile<_Tp>::type>::type    type;
    };
    

    3.4、std::_Reference_wrapper_base解析

    std::_Reference_wrapper_base位于libstdc++-v3\include\std\functional

    template<typename _Tp>
    struct _Reference_wrapper_base
        :_Reference_wrapper_base_impl<
         __has_argument_type<_Tp>::value,
         __has_first_argument_type<_Tp>::value
         && __has_second_argument_type<_Tp>::value,
         _Tp>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1)> : unary_function<_T1, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const> : unary_function<_T1, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) volatile> : unary_function<_T1, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(_T1) const volatile> : unary_function<_T1, _Res>
    {};
    
    // - a function type (binary)
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2)> : binary_function<_T1, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const> : binary_function<_T1, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) volatile> : binary_function<_T1, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(_T1, _T2) const volatile> : binary_function<_T1, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res(*)(_T1)> : unary_function<_T1, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res(*)(_T1, _T2)> : binary_function<_T1, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)()> : unary_function<_T1*, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2)> : binary_function<_T1*, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)() const> : unary_function<const _T1*, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const> : binary_function<const _T1*, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)() volatile> : unary_function<volatile _T1*, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) volatile> : binary_function<volatile _T1*, _T2, _Res>
    {};
    
    template<typename _Res, typename _T1>
    struct _Reference_wrapper_base<_Res (_T1::*)() const volatile> : unary_function<const volatile _T1*, _Res>
    {};
    
    template<typename _Res, typename _T1, typename _T2>
    struct _Reference_wrapper_base<_Res (_T1::*)(_T2) const volatile> : binary_function<const volatile _T1*, _T2, _Res>
    {};
    

    从代码中可以看出,std::_Reference_wrapper_base继承于std::unary_function或者std::binary_function,在实际编程中对std::reference_wrapper的影响不大,除非引用的是一个函数对象,所以在这里就不分析它的具体作用了,大家自己去查一下unary_functionbinary_function是啥东西就行了

    4、总结

    std::refstd::cref在函数式编程中的作用是非常大的,C++标准库中多次使用到了它们。而std::refstd::cref事实上是模板函数,返回值是一个std::reference_wrapper对象,而std::reference_wrapper虽然是一个对象,可是他却能展现出和普通引用类似的效果,这点和前一篇文章讲的智能指针如出一辙(事实上标准库大多是这样设计的,这也是运算符重载存在的一个重要意义)。当我们在函数式编程(如std::bind)中需要对参数进行引用传递时,只需要使用用std::refstd::cref修饰该引用即可。

    最后,如果大家觉得本文写得好的话麻烦点赞收藏关注一下谢谢,也可以关注该专栏,以后会有更多优质文章输出的。

    展开全文
  • c++ 知识点 std::function 使用

    万次阅读 多人点赞 2018-09-20 18:50:43
    这是c++11新添加的,头文件#include &lt;functional&gt; 官方说明: Class templatestd::functionis a general-purpose polymorphic ... Instances ofstd::functioncan store, copy, and invoke anyCall...

     

    这是c++11新添加的,头文件#include <functional>

     

    官方说明:

    Class template std::function is a general-purpose polymorphic function wrapper. Instances of std::function can store, copy, and invoke any Callable target -- functions, lambda expressionsbind expressions, or other function objects, as well as pointers to member functions and pointers to data members.

    The stored callable object is called the target of std::function. If a std::function contains no target, it is called empty. Invoking the target of an empty std::function results in std::bad_function_call exception being thrown.

    std::function satisfies the requirements of CopyConstructible and CopyAssignable.

     

    类模板std::function是一种通用的多态函数包装器。std::function可以存储,复制和调用任何Callable 目标的实例- 函数,lambda表达式绑定表达式或其他函数对象,以及指向成员函数和指向数据成员的指针。

    所存储的可调用对象被称为目标std::function。如果a不std::function包含目标,则将其称为。调用目标的的std::function的结果的std :: bad_function_call抛出异常。

    std::function满足CopyConstructibleCopyAssignable的要求。

     

    个人浅解:

    将其当做std::string    、std::vector<> 、这样的类型就可以了。只不过其值为函数指针,但比函数指针更灵活。

    因为std::function  是一种模板,所以要传入类型,就如std::vector<int>  传入类型int一样

    不过,std::function传入的是函数类型  返回值 (参数类型) 如:std::function<void (int)>

     

    示例1 : 普通函数

     

    void gFunc()
    {
    	cout << "gFunc" << endl;
    }
    int main()
    {
    	std::function<void()> f = gFunc;
    	f();
    
    	getchar();
    	return 0;
    }

     

    示例2 模板函数

    template <class T>
    T g_Add(T i, T j)
    {
    	cout << i + j;
    	return i + j;
    }
    
    
    int main()
    {
    	std::function<int(int,int)> f = g_Add<int>;
    	f(2,3);
    
    	getchar();
    	return 0;
    }

     

    示例三: 匿名函数

    auto g_Lambda = [](int i, int j)
    {
    	return i + j;
    }; //匿名函数 此处有分号
    
    int main()
    {
    	std::function<int(int, int)> f = g_Lambda;
    	cout<<f(2,3);
    
    	getchar();
    	return 0;
    }
    

    示例四:函数对象

    /函数对象
    struct Add
    {
    	int operator()(int i, int j)
    	{
    		return i + j;
    	}
    };
    
    //模板函数对象
    template <class T>
    struct AddT
    {
    	T operator()(T i, T j)
    	{
    		return i + j;
    	}
    };
    
    
    int main()
    {
    	std::function<int(int, int)> f = Add();
    	cout<<f(2,3)<<endl;
    
    	std::function<int(int, int)> ft = AddT<int>();
    	cout << ft(5, 6)<<endl;
    
    	getchar();
    	return 0;
    }

     

    示例5:类成员函数

    class Computer
    {
    public:
    	static int Add(int i, int j)
    	{
    		return i + j;
    	}
    
    	template<class T>
    	static T AddT(T i, T j)
    	{
    		return i + j;
    	}
    
    	int AddN(int i, int j)
    	{
    		return i + j;
    	}
    };
    
    //存储对成员函数的调用 
    
    int main()
    {
    	//1、 类静态函数
    	std::function<int(int, int)> f = &Computer::Add;
    	cout << f(1, 1) << endl;
    
    	//2、 类静态模板函数
    	std::function<int(int, int)> ft = &Computer::AddT<int>;
    	cout << ft(1, 1) << endl;
    
    
    
    	//普通函数绑定  需要构造类对象
    	Computer c;
    
    	//3、 普通函数 需使用bind,将类对象地址 &c 绑定上
    	std::function<int(int, int)> fN = std::bind(&Computer::AddN, &c, placeholders::_1, placeholders::_2);
    	cout << fN(1, 1) << endl;
    
    
    	//4、普通函数, 也可以这样调用  个人觉得这个比 bind 麻烦,不建议
    	std::function <int(const Computer &, int, int)> fN2 = &Computer::AddN;
    	cout << fN2(c,1, 1) << endl;
    
    
    
    
    
    	getchar();
    	return 0;
    }
    

     

     再补充一个 cppreference.com的例子

    #include <functional>
    #include <iostream>
     
    struct Foo {
        Foo(int num) : num_(num) {}
        void print_add(int i) const { std::cout << num_+i << '\n'; }
        int num_;
    };
     
    void print_num(int i)
    {
        std::cout << i << '\n';
    }
     
    struct PrintNum {
        void operator()(int i) const
        {
            std::cout << i << '\n';
        }
    };
     
    int main()
    {
        // store a free function
        std::function<void(int)> f_display = print_num;
        f_display(-9);
     
        // store a lambda
        std::function<void()> f_display_42 = []() { print_num(42); };
        f_display_42();
     
        // store the result of a call to std::bind
        std::function<void()> f_display_31337 = std::bind(print_num, 31337);
        f_display_31337();
     
        // store a call to a member function
        std::function<void(const Foo&, int)> f_add_display = &Foo::print_add;
        const Foo foo(314159);
        f_add_display(foo, 1);
        f_add_display(314159, 1);
     
        // store a call to a data member accessor
        std::function<int(Foo const&)> f_num = &Foo::num_;
        std::cout << "num_: " << f_num(foo) << '\n';
     
        // store a call to a member function and object
        using std::placeholders::_1;
        std::function<void(int)> f_add_display2 = std::bind( &Foo::print_add, foo, _1 );
        f_add_display2(2);
     
        // store a call to a member function and object ptr
        std::function<void(int)> f_add_display3 = std::bind( &Foo::print_add, &foo, _1 );
        f_add_display3(3);
     
        // store a call to a function object
        std::function<void(int)> f_display_obj = PrintNum();
        f_display_obj(18);
    }
    
    
    
    -9
    42
    31337
    314160
    314160
    num_: 314159
    314161
    314162
    18
    
    

     

    参考资料:

    https://www.cnblogs.com/heartchord/p/5017071.html

    https://en.cppreference.com/w/cpp/utility/functional/function

    展开全文
  • c++ 之 std::move 原理实现与用法总结

    万次阅读 多人点赞 2018-11-30 10:40:30
    中提供了一个有用的函数std::move,std::move并不能移动任何东西,它唯一的功能是将一个左值强制转化为右值引用,继而可以通过右值引用使用该值,以用于移动语义。从实现上讲,std::move基本等同于一个类型转换:...

    在C++11中,标准库在<utility>中提供了一个有用的函数std::move,std::move并不能移动任何东西,它唯一的功能是将一个左值强制转化为右值引用,继而可以通过右值引用使用该值,以用于移动语义。从实现上讲,std::move基本等同于一个类型转换:static_cast<T&&>(lvalue);

    std::move函数可以以非常简单的方式将左值引用转换为右值引用。(左值 右值 引用 左值引用)概念 https://blog.csdn.net/p942005405/article/details/84644101

    1. C++ 标准库使用比如vector::push_back 等这类函数时,会对参数的对象进行复制,连数据也会复制.这就会造成对象内存的额外创建, 本来原意是想把参数push_back进去就行了,通过std::move,可以避免不必要的拷贝操作。
    2. std::move是将对象的状态或者所有权从一个对象转移到另一个对象,只是转移,没有内存的搬迁或者内存拷贝所以可以提高利用效率,改善性能.。
    3. 对指针类型的标准库对象并不需要这么做.

    用法:

    原lvalue值被moved from之后值被转移,所以为空字符串. 

    //摘自https://zh.cppreference.com/w/cpp/utility/move
    #include <iostream>
    #include <utility>
    #include <vector>
    #include <string>
    int main()
    {
        std::string str = "Hello";
        std::vector<std::string> v;
        //调用常规的拷贝构造函数,新建字符数组,拷贝数据
        v.push_back(str);
        std::cout << "After copy, str is \"" << str << "\"\n";
        //调用移动构造函数,掏空str,掏空后,最好不要使用str
        v.push_back(std::move(str));
        std::cout << "After move, str is \"" << str << "\"\n";
        std::cout << "The contents of the vector are \"" << v[0]
                                             << "\", \"" << v[1] << "\"\n";
    }

    输出:

    After copy, str is "Hello"
    After move, str is ""
    The contents of the vector are "Hello", "Hello"
    

    std::move 的函数原型定义

    template <typename T>
    typename remove_reference<T>::type&& move(T&& t)
    {
    	return static_cast<typename remove_reference<T>::type&&>(t);
    

     

    原型定义中的原理实现:

     首先,函数参数T&&是一个指向模板类型参数的右值引用,通过引用折叠,此参数可以与任何类型的实参匹配(可以传递左值或右值,这是std::move主要使用的两种场景)。关于引用折叠如下:

          公式一)X& &、X&& &、X& &&都折叠成X&,用于处理左值

    string s("hello");
    std::move(s) => std::move(string& &&) => 折叠后 std::move(string& )
    此时:T的类型为string&
    typename remove_reference<T>::type为string 
    整个std::move被实例化如下
    string&& move(string& t) //t为左值,移动后不能在使用t
    {
        //通过static_cast将string&强制转换为string&&
        return static_cast<string&&>(t); 
    }


          公式二)X&& &&折叠成X&&,用于处理右值

    std::move(string("hello")) => std::move(string&&)
    //此时:T的类型为string 
    //     remove_reference<T>::type为string 
    //整个std::move被实例如下
    string&& move(string&& t) //t为右值
    {
        return static_cast<string&&>(t);  //返回一个右值引用
    }


    简单来说,右值经过T&&传递类型保持不变还是右值,而左值经过T&&变为普通的左值引用.

    ②对于static_cast<>的使用注意:任何具有明确定义的类型转换,只要不包含底层const,都可以使用static_cast。

    double d = 1;
    void* p = &d;
    double *dp = static_cast<double*> p; //正确
     
    const char *cp = "hello";
    char *q = static_cast<char*>(cp); //错误:static不能去掉const性质
    static_cast<string>(cp); //正确 


    ③对于remove_reference是通过类模板的部分特例化进行实现的,其实现代码如下

    //原始的,最通用的版本
    template <typename T> struct remove_reference{
        typedef T type;  //定义T的类型别名为type
    };
     
    //部分版本特例化,将用于左值引用和右值引用
    template <class T> struct remove_reference<T&> //左值引用
    { typedef T type; }
     
    template <class T> struct remove_reference<T&&> //右值引用
    { typedef T type; }   
      
    //举例如下,下列定义的a、b、c三个变量都是int类型
    int i;
    remove_refrence<decltype(42)>::type a;             //使用原版本,
    remove_refrence<decltype(i)>::type  b;             //左值引用特例版本
    remove_refrence<decltype(std::move(i))>::type  b;  //右值引用特例版本 


    总结:

    std::move实现,首先,通过右值引用传递模板实现,利用引用折叠原理将右值经过T&&传递类型保持不变还是右值,而左值经过T&&变为普通的左值引用,以保证模板可以传递任意实参,且保持类型不变。然后我们通过static_cast<>进行强制类型转换返回T&&右值引用,而static_cast<T>之所以能使用类型转换,是通过remove_refrence<T>::type模板移除T&&,T&的引用,获取具体类型T。


    参考链接:

    https://blog.csdn.net/fengbingchun/article/details/52558914 

    https://blog.csdn.net/cpriluke/article/details/79462388 

    https://blog.csdn.net/swartz_lubel/article/details/59620868

    展开全文
  • python 标准差计算(std

    万次阅读 多人点赞 2017-12-28 16:15:43
    numpy.std() 求标准差的时候默认是除以 n 的,即是有偏的,np.std无偏样本标准差方式为 ddof = 1; pandas.std() 默认是除以n-1 的,即是无偏的,如果想和numpy.std() 一样有偏,需要加上参数ddof=0 ,即pandas....
  • std::ref和std::cref使用

    万次阅读 多人点赞 2018-08-09 20:42:44
    std::ref和std::cref 解释 std::ref 用于包装按引用传递的值。 std::cref 用于包装按const引用传递的值。 为什么需要std::ref和std::cref bind()是一个函数模板,它的原理是根据已有的模板,生成一个函数,...
  • std::cout 与 cout 有什么区别

    万次阅读 多人点赞 2019-02-22 10:29:10
    std是一个命名空间(namespace),‘::’是作用域运算符,cout是std空间中的一个函数名。使用cout时,必须有使用std命名空间的说明,有两种说明方式。 方式一:每次使用时对cout说明: std::cout &lt;&lt;...
  • pandas中std和numpy的np.std区别

    万次阅读 2019-07-03 23:43:39
    pandas中std和numpy的std区别 pandas中Series.std的官方文档 numpy中numpy.std的官方文档 原理     计算标准差时,需要注意numpy中的std和pandas的std在计算标准差时,默认的计算结果会存在不一致的问题。  ...
  • C++/C++11中std::transform的使用

    万次阅读 多人点赞 2017-03-18 11:48:28
    std::transform在指定的范围内应用于给定的操作,并将结果存储在指定的另一个范围内。要使用std::transform函数需要包含<algorithm>头文件。 以下是std::transform的两个声明,一个是对应于一元操作,一个是...
  • std::mutex 头文件是<mutex>,mutex是用来保证线程同步的,防止不同的线程同时操作同一个共享数据。使用比较简单,定义之后,调用加锁解锁函数即可。 std::mutex m; m.lock(); //被保护的操作 m_unlock(); ...
  • 在公司说的项目代码中看到了std::function、std::bind、std::placeholders三个C++11的特性,通过了解之后,发现还是挺有用的,在这里记录下吧。似乎这三个特性一般都是一起使用的,所以也一起讲了。 三个特性都在...
  • C++11中的std::bind

    万次阅读 多人点赞 2019-08-29 16:09:59
    看看这段代码 这几天学习Cocos2d-x,看到了以下的一段代码: // new callbacks based on C++11 #define CC_CALLBACK_0(__selector__,__target__, ...) std::bind(&__selector__,__tar...
  • std::unique_lock, std::lock_guard, std::recursive_mutex可以简单理解为对std::mutex的封装,且对互斥量的unlock是在对象(比如std::unique_lock对象)销毁时执行。 下面举两个例子,注意红色标注的部分: ...
  • C++之智能指针std::shared_ptr简单使用和理解

    万次阅读 多人点赞 2018-11-04 00:52:43
    1 智能指针std::shared_ptr相关知识和如何使用 我们这里先说下智能指针std::shared_ptr,因为我看到我我们项目c++代码里面用得很多,我不是不会,所以记录学习下 先让ubuntu终端支持c++11,如果自己的电脑还没配置号,...
  • std::future和std::shared_future区别

    千次阅读 2019-01-19 23:12:32
    std::future使用 可以处理所有在线程间数据转移的必要同步,但是std::future模型独享同步结果的所有权。并且通过 get() 函数,一次性的获取数据,让并发访问变的毫无意义。你的并发代码没有办法让多个线程等待同一...
  • std::floor和std:ceil简述

    万次阅读 2017-12-02 13:55:30
    std::floor 和 std::ceil都是对变量进行四舍五入,只不过四舍五入的方向不同。  1: std::floor -->向下取整数 2: std::ceil -->向上取整数: 例如: 5.88 std::floor(5.88) = 5;  std::ceil(5.88) = 6;
  • std::set、std::list、std::vector在erase的区别
  • C++中std::sort/std::stable_sort/std::partial_sort的区别及使用
  • C++中的using namespace std的作用

    万次阅读 多人点赞 2018-09-09 20:19:54
    C++中的using namespace std的作用  所谓namespace,是指标识符的各种可见范围。C++标准程序库中的所有标识符都被定义于一个名为std的namespace中。  iostream和iostream.h的区别:  后缀为.h的头文件C++标注...
  • C++17之std::optional

    万次阅读 2019-09-05 21:45:03
    在编程中,我们经常遇到这样的情况:我们可能返回/传递/使用某种类型的对象。也就是说,我们可以有某个类型的值,也可以没有任何值。...std::optional<>以一种类型安全的方式提供了这样的对象。...
  • std::function和std::bind用法

    千次阅读 2018-09-04 14:58:31
    std::bind()  std::bind 主要用于绑定生成目标函数,一般用于生成的回调函数,cocos的回退函数都是通过std::bind和std::function实现的。两个点要明白: 1.绑定全局或者静态函数比绑定成员函数少了个成员变量,...
  • C++11中std::future的使用

    万次阅读 多人点赞 2020-01-30 15:28:45
    C++11中的std::future是一个模板类。std::future提供了一种用于访问异步操作结果的机制。std::future所引用的共享状态不能与任何其它异步返回的对象共享(与std::shared_future相反)( std::future references shared ...
  • stdint.h头文件

    千次下载 热门讨论 2013-07-13 16:47:50
    很多项目经常使用的两个头文件inttypes.h stdint.h,否则会报错。网上很多资料,但基本上不可用。这两个文件,我在自己的项目中运行良好。
  • std::tie详解

    千次阅读 2019-10-11 14:16:07
    std::tie:创建左值引用的tuple,或将 tuple 解包为独立对象 返回值 含左值引用的std::tuple对象。 注意 std::tie可用于解包std::pair,因为std::tuple拥有从 pair 的转换赋值: 示例 std::tie能用于引入字典...
  • leetcode —— Two Sum 刷题刷到std::pair和make_pair()函数,记录下用法,做一个
  • C++ std::move与std::swap

    千次阅读 2019-04-06 19:43:45
    中提供了一个有用的函数std::move,std::move并不能移动任何东西,它唯一的功能是将一个左值强制转化为右值引用,继而可以通过右值引用使用该值,以用于移动语义,确切地说,它使一个值易于移动。从实现上讲,std::...
  • C++11 std::bind 和 std::placeholder

    千次阅读 2019-07-07 22:35:53
    @time 2019-07-07 ...一、std::function https://blog.csdn.net/itworld123/article/details/95034012 二、std::bind 1、函数原型 template<typename _Result, typename _Func, typename... _B...
  • std命名空间

    千次阅读 2019-05-15 19:05:00
    C++ std命名空间 1. 什么是命名空间 在编程语言中,命名空间是一种特殊的作用域,它包含了处于该作用域中的所有标示符,而且其本身也是由标示符表示的。命名空间的使用目的是为了将逻辑相关的标示符限定在一起,...
  • C++11的右值引用、移动语义(std::move)和完美转发(std::forward)详解1、源码准备2、C++11右值引用概念2.1、左值和右值2.2、右值引用3、C++11的移动语义(std::move)和完美转发(std::forward)3.1、移动语义...
  • C++,cout和std::cout的区别

    万次阅读 2016-03-24 14:49:33
    #include "stdafx.h" #include #include using namespace std; int main() { //using std::cout; //using std::endl;.../////前面已定义std,则后面可以直接调用,不必写std::cout... //using std:

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,286,853
精华内容 1,314,741
关键字:

std