豌豆

using 关键字在 C++ 中的几种用法

2018/03/13 14,246

对C++中 using关键字的几种用法的总结：

1. using 声明

using 声明 (using declaration) 是将命名空间中单个名字注入到当前作用域的机制，使得在当前作用域下访问另一个作用域下的成员时无需使用限定符 ::

// ...
{
    using std::map
    map<int, std::string> the_map; //ok
}
map<int, std::string> the_map2;  //error

1

2

3

4

5

6

// ...

{

using std::map

map<int, std::string> the_map; //ok

}

map<int, std::string> the_map2; //error

using 声明将其它 namespace 的成员引入本命名空间的 当前作用域 (包括其嵌套作用域) 。一个 using 声明一次只引入一个命名空间成员，它使得无论程序中使用哪些名字，都非常准确。
利用 using 声明，可以改变派生类对父类成员的访问控制:

class Base{
protected:
    int bn1;
    int bn2;
};

class Derived: private Base{
public:
    using Base::bn1;
};

class DerivedAgain: public Derived{
};

int main(){
    Derived d;
    DerivedAgain da; 
    d.bn1 = 1;
    d.bn2 = 2; //error, 'bn2' is a private member of 'Base'
    da.bn1 = 3;  //ok
    std::cout<<d.bn1<<std::endl;

    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

class Base{

protected:

int bn1;

int bn2;

};

class Derived: private Base{

public:

using Base::bn1;

};

class DerivedAgain: public Derived{

};

int main(){

Derived d;

DerivedAgain da;

d.bn1 = 1;

d.bn2 = 2; //error, 'bn2' is a private member of 'Base'

da.bn1 = 3; //ok

std::cout<<d.bn1<<std::endl;

return 0;

}

尽管 Derived 对 base 是私有继承，但通过 using 声明，我们还是可以在 Derived 中访问其成员，且后续的继承同样不受 private 限定的影响。

继续阅读

Coding c++, c++11

C++11/14 新特性 (多线程)

2017/03/28 6,637

在 C++11 之前，C++ 标准并没有提供统一的并发编程标准，也没有提供语言级别的支持。这导致我们在编写可移植的多线程程序时很不方便，往往需要面向不同的平台进行不同的实现，或者引入一些第三方平台，如Boost,pthread_win32 等。从C++11开始，对并发编程进行了语言级别的支持，使用使用C++进行并发编程方便了很多。这里介绍C++11并发编程的相关特性。

1 线程

1.1 线程的创建

std::thread 的构造函数如下：

template< class Function, class... Args > 
explicit thread( Function&& f, Args&&... args );

1 2	template< class Function, class... Args > explicit thread( Function&& f, Args&&... args );

我们只需要提供线程函数或函数对象，即可以创建线程，并可以同时指定线程函数的参数。

#include <iostream>
#include <thread>
using namespace std;

void func(const string& str){
    cout<<str<<endl;
}

class FuncCls{
public:
    void operator()(){
        cout<<"Funcls called"<<endl;
    }
};

int main(void){
    thread t1(func,"Hello World");
    FuncCls fcls;
    thread t2(fcls);

    if(t1.joinable()){
        t1.join();
    }
    t2.join();
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

#include <iostream>

#include <thread>

using namespace std;

void func(const string& str){

cout<<str<<endl;

}

class FuncCls{

public:

void operator()(){

cout<<"Funcls called"<<endl;

}

};

int main(void){

thread t1(func,"Hello World");

FuncCls fcls;

thread t2(fcls);

if(t1.joinable()){

t1.join();

}

t2.join();

return 0;

}

join函数将会阻塞线程，直到线程函数执行完毕，主线程才会接着执行。如果线程函数有返回值，返回值将被忽略。在使用线程对象的过程中，我们需要注意线程对象的生命周期。如果线程对象先于线程函数结束，那么将会出现不可预料的错误。可以通过线程阻塞的方式来等待线程函数执行完(join)，或让线程在后台执行。如果不希望线程被阻塞，可以调用线程的 detach() 函数，将线程与线程对象分离。但需要注意的是，detach 之后的线程无法再使用join来进行阻塞了，即detach之后的线程，我们无法控制了。当我们不确定一个线程是否可以join时，可以先使用 thead::joinable() 来进行判断。

另外，我们还可以通过 std::bind, lambda 来创建线程(其实就是使用函数对象创建线程)。

线程不可以被复制，但是可以被移动:
继续阅读

Coding c++, c++11, mutex, thread, 多线程

C++11/14 新特性(function/bind 可调用对象包装器与绑定器)

2017/02/28 6,075

1 可调用对象

在 C++ 中，可调用对象一般是指：

一个函数指针
一个重载 () 操作符的类对句(仿函数)
一个可被转换为函数指针的类对象
一个类成员函数指针

#include <iostream>

void func(void)
{
    std::cout<<"func(void) called"<<std::endl;
}

struct Foo
{
    void operator()(void)
    {
        std::cout<<"Foo::()(void) called"<<std::endl;
    }
};

struct Bar
{
    using ft_t = void(*)(void);
    static void func(void)
    {
        std::cout<<"Bar::func(void) called"<<std::endl;
    }

    operator ft_t(void)
    {
        return func;
    }
};

struct A
{
    int m_a;
    void mem_func(void)
    {
        std::cout<<"A:memfunc(void) called and m_a="<<m_a<<std::endl;
    }
};


int main() {
    //1.函数指针
    void(* func_ptr)(void) = &func;
    func_ptr();

    //2.仿函数
    Foo foo;
    foo();

    //3.可被转换为函数指针的类对象
    Bar bar;
    bar();

    //4.类成员函数指针或类成员指针
    void (A::*mem_func_ptr)(void) = &A::mem_func;
    int A::*mem_obj_ptr = &A::m_a;
    A aa;
    (aa.*mem_obj_ptr) = 123;
    (aa.*mem_func_ptr)();

    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

#include <iostream>

void func(void)

{

std::cout<<"func(void) called"<<std::endl;

}

struct Foo

{

void operator()(void)

{

std::cout<<"Foo::()(void) called"<<std::endl;

}

};

struct Bar

{

using ft_t = void(*)(void);

static void func(void)

{

std::cout<<"Bar::func(void) called"<<std::endl;

}

operator ft_t(void)

{

return func;

}

};

struct A

{

int m_a;

void mem_func(void)

{

std::cout<<"A:memfunc(void) called and m_a="<<m_a<<std::endl;

}

};

int main() {

//1.函数指针

void(* func_ptr)(void) = &func;

func_ptr();

//2.仿函数

Foo foo;

foo();

//3.可被转换为函数指针的类对象

Bar bar;

bar();

//4.类成员函数指针或类成员指针

void (A::*mem_func_ptr)(void) = &A::mem_func;

int A::*mem_obj_ptr = &A::m_a;

A aa;

(aa.*mem_obj_ptr) = 123;

(aa.*mem_func_ptr)();

return 0;

}

上例中的这些对象(func_ptr,foo,bar,mem_func_ptr,mem_obj_ptr) 均可称之为 “可调用对象”。相应的，其类型可被称作“可调用类型”。注意这里只有成员函数有成员函数指针而没有函数类型或函数引用类型，这是因为函数类型并不能直接用于定义对象，而函数引用或以看做一个 const 的函数指针。可调用对象具有比较统一的调用形式，即使用括号操作(除成员函数指针)，而定义的方法各不一样。这样我们在试图使用统一的方式保存，或传递一个可调用对象时，会十分烦琐。

2 std::function 可调用对象包装器

std::function 是一个类模板，它可以容纳除了类成员(函数)指针之外的所有可调用对象。通过指定它的模板参数，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟调用它们。
继续阅读

Coding c++, c++11

C++11/14 新特性 (使用 chrono 进行时间处理)

2017/01/03 5,466

在c++11以前，我们获取当前时间的时间戳，需要借助于第三方库，如 boost ，或者针对不同的操作做不同的处理:

#ifndef _MSC_VER
#include <sys/time.h>
#endif

long long GetTimeSpan()
{
    long long llTimeMs = 0L;
#ifdef _MSC_VER
    timeb tb;
    ftime(&tb);

    lTimeMs = tb.time * 1000 + tb.millitm;

#else
    timeval tmv;
    gettimeofday(&tmv,NULL);


    llTimeMs = (long long)(tmv.tv_sec) * 1000L + tmv.tv_usec / 1000;

#endif
    return llTimeMs;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

#ifndef _MSC_VER

#include <sys/time.h>

#endif

long long GetTimeSpan()

{

long long llTimeMs = 0L;

#ifdef _MSC_VER

timeb tb;

ftime(&tb);

lTimeMs = tb.time * 1000 + tb.millitm;

#else

timeval tmv;

gettimeofday(&tmv,NULL);

llTimeMs = (long long)(tmv.tv_sec) * 1000L + tmv.tv_usec / 1000;

#endif

return llTimeMs;

}

而在c++11中，这个问题得到解决。 c++11 标准库中提供 chrono库，用来处理时间相关的数据。

1 duration 记录时长

duration 表示一段时间间隔。其原型：

template <class _Rep, class _Period>
class duration;

1 2	template <class _Rep, class _Period> class duration;

_Rep 为一个数值类型，如 int, long, 用来表示时钟数的类型。 _Period 为一个默认的模板参数 std::ratio，表示时钟周期。 ratio的原型：

template <intmax_t _Num, intmax_t _Den = 1>
class ratio

1 2	template <intmax_t _Num, intmax_t _Den = 1> class ratio

它表示一个时钟周期的秒数。_Num 代表分子，_Den代表分母，它们的比值就是一个时钟周期，可以通过调整分子与分母来表示任意一个时钟周期。如 ratio<1> 表示一个时钟周期为1秒，ratio<3600>表示一个时钟周期为1小时，ratio<1,1000>表示一个时钟周期为1毫秒，ratio<1,2>表示一个时钟周期为0.2秒，ratio<9/7>表示一个时钟周期为9/7秒。标准库将一些常用的时钟周期做了定义：

typedef ratio<1LL, 1000000000000000000LL> atto;
typedef ratio<1LL,    1000000000000000LL> femto;
typedef ratio<1LL,       1000000000000LL> pico;
typedef ratio<1LL,          1000000000LL> nano;
typedef ratio<1LL,             1000000LL> micro;
typedef ratio<1LL,                1000LL> milli;
typedef ratio<1LL,                 100LL> centi;
typedef ratio<1LL,                  10LL> deci;
typedef ratio<                 10LL, 1LL> deca;
typedef ratio<                100LL, 1LL> hecto;
typedef ratio<               1000LL, 1LL> kilo;
typedef ratio<            1000000LL, 1LL> mega;
typedef ratio<         1000000000LL, 1LL> giga;
typedef ratio<      1000000000000LL, 1LL> tera;
typedef ratio<   1000000000000000LL, 1LL> peta;
typedef ratio<1000000000000000000LL, 1LL> exa;

typedef duration<long long,         nano> nanoseconds;
typedef duration<long long,        micro> microseconds;
typedef duration<long long,        milli> milliseconds;
typedef duration<long long              > seconds;
typedef duration<     long, ratio<  60> > minutes;
typedef duration<     long, ratio<3600> > hours;

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

typedef ratio<1LL, 1000000000000000000LL> atto;

typedef ratio<1LL, 1000000000000000LL> femto;

typedef ratio<1LL, 1000000000000LL> pico;

typedef ratio<1LL, 1000000000LL> nano;

typedef ratio<1LL, 1000000LL> micro;

typedef ratio<1LL, 1000LL> milli;

typedef ratio<1LL, 100LL> centi;

typedef ratio<1LL, 10LL> deci;

typedef ratio< 10LL, 1LL> deca;

typedef ratio< 100LL, 1LL> hecto;

typedef ratio< 1000LL, 1LL> kilo;

typedef ratio< 1000000LL, 1LL> mega;

typedef ratio< 1000000000LL, 1LL> giga;

typedef ratio< 1000000000000LL, 1LL> tera;

typedef ratio< 1000000000000000LL, 1LL> peta;

typedef ratio<1000000000000000000LL, 1LL> exa;

typedef duration<long long, nano> nanoseconds;

typedef duration<long long, micro> microseconds;

typedef duration<long long, milli> milliseconds;

typedef duration<long long > seconds;

typedef duration< long, ratio< 60> > minutes;

typedef duration< long, ratio<3600> > hours;

在不同的时钟周期中，我们可以使用 chrono_cast 来进行转换。两个 duration还可以进行加减运算：

#include <chrono>
#include <iostream>
using namespace std;

int main(int argc, const char * argv[]) {

    chrono::hours hrs(2);   //两小时
    cout<<hrs.count()<<" hours = ";  //count() 函数获取时钟周期下的时钟数
    chrono::minutes mns = chrono::duration_cast<chrono::minutes>(hrs); //120分钟
    cout<<mns.count()<<" minutes"<<endl;

    chrono::minutes tm = hrs - chrono::minutes(30);  //时长的加减运算
    cout<<hrs.count()<<" hours - 30 minutes = " <<tm.count()<<" minutes = ";

    typedef chrono::duration<double,ratio<3600,1>> hs;  //时长的类型转换。注意 duration 的 _Rep 参数类型。
    hs c = chrono::duration_cast<hs>(tm);
    cout<<c.count()<<" hours"<<endl;


    return 0;
}

//#  输出 #：
// 2 hours = 120 minutes
// 2 hours - 30 minutes = 90 minutes = 1.5 hours

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

#include <chrono>

#include <iostream>

using namespace std;

int main(int argc, const char * argv[]) {

chrono::hours hrs(2); //两小时

cout<<hrs.count()<<" hours = "; //count() 函数获取时钟周期下的时钟数

chrono::minutes mns = chrono::duration_cast<chrono::minutes>(hrs); //120分钟

cout<<mns.count()<<" minutes"<<endl;

chrono::minutes tm = hrs - chrono::minutes(30); //时长的加减运算

cout<<hrs.count()<<" hours - 30 minutes = " <<tm.count()<<" minutes = ";

typedef chrono::duration<double,ratio<3600,1>> hs; //时长的类型转换。注意 duration 的 _Rep 参数类型。

hs c = chrono::duration_cast<hs>(tm);

cout<<c.count()<<" hours"<<endl;

return 0;

}

//# 输出 #：

// 2 hours = 120 minutes

// 2 hours - 30 minutes = 90 minutes = 1.5 hours

继续阅读

Coding c++, c++11, chrono, duration, system_clock

C++11/14 新特性(for循环)

2016/12/05 6,114

在C++ 中，遍历一个容器的方法一般是这样的:

#include <iostream>
#include <vector>
int main(void)
{
    std::vector<int> vec;
    //do sth
    std::vector<int>::iterator it = vec.begin();
    for(; it != vec.end(); ++it)
    {
        std::cout<< *it <<std::endl;
    }
    return 0;
}

1

2

3

4

5

6

7

8

9

10

11

12

13

#include <iostream>

#include <vector>

int main(void)

{

std::vector<int> vec;

//do sth

std::vector<int>::iterator it = vec.begin();

for(; it != vec.end(); ++it)

{

std::cout<< *it <<std::endl;

}

return 0;

}

对STL比较熟悉的程序员肯定还知道在 <algorithm> 中有一个 for_each 算法，可以用来完成上述功能：

int main(void)
{
    std::vector<int> vec;
    //do sth
    std::for_each(vec.begin(), vec.end(), [](auto val){std::cout<<val<<std::endl;});
    return 0;
}

1

2

3

4

5

6

7

int main(void)

{

std::vector<int> vec;

//do sth

std::for_each(vec.begin(), vec.end(), [](auto val){std::cout<<val<<std::endl;});

return 0;

}

这里借助了 auto 关键字和 lambda 表达式简化了操作。 std::for_each 比起前面 for 循环，最大的好处是不再需要关注迭代器的概念，而只需要关心容器中的元素类型即可。但这两种方法，都必须显式的给出容器有开头和结尾(begin,end).这是因为上面的两种方法都不是基于范围(range)来设计的. 范围的概念在很多高级语言中都有涉及。例如下面这段 python 代码：

arr = [1,2,3,4,5]
for n in arr:
    print n

1

2

3

arr = [1,2,3,4,5]

for n in arr:

print n

在这种循环中，不再需要关心容器的两端，循环会自动以容器的范围进行展开。而且这种语法可以清楚地表明它的意义。使用这种方式进行循环无疑会使编码和维护更加简便。现在，c++11 可有了基于范围的 for 循环：

继续阅读

Coding c++, c++11

C++11/14 新特性（类型/初始化/智能指针）

2016/12/01 5,903

数据类型

1.long long

long long 数据类型，提供至少 64 位的整型数据。

2.nullptr

C++11 推荐使用 nullptr 表示空指针，不再推荐使用 NULL 或 0 表示空指针。 NULL为从 C 语言中引进的，在 C 语言中一般被定义为宏：

#ifdef __cplusplus
#define NULL 0
#else
#define NULL ((void*)0)
#endif

1

2

3

4

5

#ifdef __cplusplus

#define NULL 0

#else

#define NULL ((void*)0)

#endif

在 C 语言中，可以将 void* 隐式转换为任意指针类型，而在 C++ 中，可以为任意类型的指针赋 0 值。所以 c++ 将 NULL 定义为 0. nullptr 是指针类型(nullptr_t),该类型的对象不允许转换到非指针类型。

3.contexpr

1).const expression 常量表达式

是指值不会改变且在编译过程中就能得到计算结果的表达式。字面量属于常量表达式，使用常量表达式初始化的 const 对象也是常量表达式。一个对象或表达式是不是常量表达式要由它的数据类型和初始值共同决定：

const int max = 1024;    // max 是常量表达式
const int min = max - 1000;    // min 是常量表达式
int nsize = 64;    //  nsize 不是常量表达式
const int sz = nsize + 1; //  nsize 不是常量表达式

1

2

3

4

const int max = 1024; // max 是常量表达式

const int min = max - 1000; // min 是常量表达式

int nsize = 64; // nsize 不是常量表达式

const int sz = nsize + 1; // nsize 不是常量表达式

尽管 size 变量的初始化值是字面常量，但是它的定义数据类型是 int 而不是 const int 。尽管 sz 定义为 const int ,但其值需要运行时才能得到，所以它也不是常量表达式。

2).constexpr 变量

C++11 中，允许将变量声明为 constexpr 类型，以便由编译器检查变量是否为一个常量表达式：声明为 constexpr 的变量一定是一个常量，且必须使用常量表达式初始化：

constexpr int max = 1024;    //是常量表达式
constexpr int min = max - 1000;    //是常量表达式
constexpr int sz = get_size();    //只有当 get_size() 是常量表达式时，定义才是常量表达式

1

2

3

constexpr int max = 1024; //是常量表达式

constexpr int min = max - 1000; //是常量表达式

constexpr int sz = get_size(); //只有当 get_size() 是常量表达式时，定义才是常量表达式

3).constexpr 函数

constexpr 可用于指示函数是一个常量表达式。这需要满足：

返回值类型是字面值类型
形参类型是字面值类型
函数体中必须有且仅有一条 return 语句

4).constexpr 与 const

const int* p = nullptr;    //p 是一个指向整型常量的指针
constexpr int* q = nullptr;    //q 是一个指向整型的常量指针

1 2	const int* p = nullptr; //p 是一个指向整型常量的指针 constexpr int* q = nullptr; //q 是一个指向整型的常量指针

这里的 p 和 q 本质是不一样的。指针 p 指向的整数是常量，而指针 q 本身是常量，其指向的整数则可以不是常量：

*p = 5;         //错误 ，p 指向的整数是一个常量，即 *p 是不可修改的
p = new int(0);  //正确 ， p 是可以修改的
*q = 5;         //正确 ， q 指向的整数的值是可以修改的
q = new int(0);         //错误 ， q 是一个常量表达式，不可修改

1

2

3

4

*p = 5; //错误，p 指向的整数是一个常量，即 *p 是不可修改的

p = new int(0); //正确， p 是可以修改的

*q = 5; //正确， q 指向的整数的值是可以修改的

q = new int(0); //错误， q 是一个常量表达式，不可修改

其中的关键在于constexpr把它所定义的对象置为了顶层const.

4.noexcept

noexcept 指示一个函数不会抛出异常。如果一个使用 noexcept 修饰的函数内部抛出了异常，编译器并不会报错，但

继续阅读

Coding auto, c++, c++11, shared_ptr, smart_ptr, weak_ptr, 智能指针

豌豆

存档

using 关键字在 C++ 中的几种用法

1. using 声明

C++11/14 新特性 (多线程)

1 线程

1.1 线程的创建

C++11/14 新特性(function/bind 可调用对象包装器与绑定器)

1 可调用对象

2 std::function 可调用对象包装器

C++11/14 新特性 (使用 chrono 进行时间处理)

1 duration 记录时长

C++11/14 新特性(for循环)

C++11/14 新特性（类型/初始化/智能指针）

数据类型

1.long long

2.nullptr

3.contexpr

1).const expression 常量表达式

2).constexpr 变量

3).constexpr 函数

4).constexpr 与 const

4.noexcept

页面

近期文章

归档

分类目录

链接

豌豆

存档

using 关键字在 C++ 中的几种用法

1. using 声明

C++11/14 新特性 (多线程)

1 线程

1.1 线程的创建

C++11/14 新特性(function/bind 可调用对象包装器与绑定器)

1 可调用对象

2 std::function 可调用对象包装器

C++11/14 新特性 (使用 chrono 进行时间处理)

1 duration 记录时长

C++11/14 新特性(for循环)

C++11/14 新特性（类型/初始化/智能指针）

数据类型

1.long long

2.nullptr

3.contexpr

1).const expression 常量表达式

2).constexpr 变量

3).constexpr 函数

4).constexpr 与 const

4.noexcept

页面

近期文章

归档

分类目录

标签

链接