C++杂七杂八

最新推荐文章于 2024-12-04 09:37:18 发布

原创最新推荐文章于 2024-12-04 09:37:18 发布 · 634 阅读

0 ·

CC 4.0 BY-SA版权

C/C++ 专栏收录该内容

26 篇文章

订阅专栏

一、extern "C"

C++支持函数重载，C不支持。void foo(int x, int y) 函数被C编译后在库中的名字为_foo，在C++编译后库中名字类似_foo_int_int。

C++提供extern "C"解决名字匹配问题。

二、 #define

注意：将表达式中的所有参数用括号括起来。e.g. #define MIN(A, B) ((A) <= (B) ? (A) : (B)

三、mutable

mutalbe的中文意思是“可变的，易变的”，跟constant（既C++中的const）是反义词。

　在C++中，mutable也是为了突破const的限制而设置的。被mutable修饰的变量，将永远处于可变的状态，即使在一个const函数中。

　我们知道，如果类的成员函数不会改变对象的状态，那么这个成员函数一般会声明成const的。但是，有些时候，我们需要在const的函数里面修改一些跟类状态无关的数据成员，那么这个数据成员就应该被mutalbe来修饰。

四、sizeof()

注意数据对齐；

虚函数表占1个指针大小；

sizeof计算栈中分配的大小，而静态变量存放在全局数据区，不会计算在内：

class A

{public:

int a;

static int b;

A();

~A()

}

sizeof(A)=4

五、inline

内敛函数与普通函数相比可以加快程序的运行速度，因为不需要中断调用，在编译的时候内敛函数可以直接被镶嵌到目标代码中。

内敛函数要做参数类型检查，优于宏定义。（宏不是函数，只是在编译前将程序中有关字符串替换为宏体；inline是函数，但在编译中不产生单独代码，而是将有关代码嵌入到调用处）

一般用于：函数不断被重复调用，且该函数只有简单的几行、不包含循环语句。

六、sizeof和strlen的区别

1.sizeof操作符的结果类型是size_t，它在头文件中typedef为unsigned int类型。该类型保证能容纳实现所建立的最大对象的字节大小。

2.sizeof是算符，strlen是函数。

3.sizeof可以用类型做参数，strlen只能用char*做参数，且必须是以''\0''结尾的。
sizeof还可以用函数做参数，比如：
short f();
printf("%d\n", sizeof(f()));
输出的结果是sizeof(short)，即2。

4.数组做sizeof的参数不退化，传递给strlen就退化为指针了。

5.大部分编译程序在编译的时候就把sizeof计算过了，是类型或是变量的长度。这就是sizeof(x)可以用来定义数组维数的原因：
char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;

6.strlen的结果要在运行的时候才能计算出来，时用来计算字符串的长度，不是类型占内存的大小。

7.sizeof后如果是类型必须加括弧，如果是变量名可以不加括弧。这是因为sizeof是个操作符不是个函数。

8.当适用了于一个结构类型时或变量， sizeof 返回实际的大小，当适用一静态地空间数组， sizeof 归还全部数组的尺寸。 sizeof 操作符不能返回动态地被分派了的数组或外部的数组的尺寸。

9.数组作为参数传给函数时传的是指针而不是数组，传递的是数组的首地址，如：
fun(char [8])
fun(char [])
都等价于 fun(char *)
在C++里参数传递数组永远都是传递指向数组首元素的指针，编译器不知道数组的大小。如果想在函数内知道数组的大小，需要这样做：进入函数后用memcpy拷贝出来，长度由另一个形参传进去：
fun(unsiged char *p1, int len)
{
unsigned char* buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}

我们能常在用到 sizeof 和 strlen 的时候，通常是计算字符串数组的长度
看了上面的详细解释，发现两者的使用还是有区别的，从这个例子可以看得很清楚：
char str[20]="0123456789";
int a=strlen(str); //a=10; >>>> strlen 计算字符串的长度，以结束符 0x00 为字符串结束。
int b=sizeof(str); //而b=20; >>>> sizeof 计算的则是分配的数组 str[20] 所占的内存空间的大小，不受里面存储的内容改变。

上面是对静态数组处理的结果，如果是对指针，结果就不一样了
char* ss = "0123456789";
sizeof(ss) 结果 4 ＝＝＝》ss是指向字符串常量的字符指针，sizeof 获得的是一个指针的之所占的空间,应该是长整型的，所以是4
sizeof(*ss) 结果 1 ＝＝＝》*ss是第一个字符其实就是获得了字符串的第一位'0' 所占的内存空间，是char类型的，占了 1 位
strlen(ss)= 10 >>>> 如果要获得这个字符串的长度，则一定要使用 strlen

七、函数指针

1. float(**def)[10]def为二级指针，指向一个一维数组的指针，数组元素都为float

2. double*(*gh)[10]gh为指向一个一维数组的指针，数组元素都为double*

3. double(*f[10])()f为一个数组，数组有10个元素，元素为函数指针，指向返回值为double的无参数的函数

4. int*((*b)[10])同int*(*b)[10]

5. long(* fun)(int)fun为指向返回值为long的参数为int的函数的指针

6. int(*(*F)(int,int))(int)F为函数指针，指向返回值为函数指针的参数为(int,int)的函数指针，其返回的函数指针指向返回值为int参数为int的函数

八、智能指针auto_ptr

已有智能指针 boost::shared_ptr见后说明

转载出处http://blog.youkuaiyun.com/hackbuteer1/article/details/7561235

智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，构造函数减少引用计数（如果引用计数减至0，则删除基础对象）。
智能指针就是模拟指针动作的类。所有的智能指针都会重载 -> 和 * 操作符。智能指针还有许多其他功能，比较有用的是自动销毁。这主要是利用栈对象的有限作用域以及临时对象（有限作用域实现）析构函数释放内存。当然，智能指针还不止这些，还包括复制时可以修改源对象等。智能指针根据需求不同，设计也不同（写时复制，赋值即释放对象拥有权限、引用计数等，控制权转移等）。auto_ptr 即是一种常见的智能指针。
智能指针通常用类模板实现：

[cpp]view plaincopy 
   
 template <class T>  
 class smartpointer  
 {  
 private:  
     T *_ptr;  
 public:  
     smartpointer(T *p) : _ptr(p)  //构造函数  
     {  
     }  
     T& operator *()        //重载*操作符  
     {  
         return *_ptr;  
     }  
     T* operator ->()       //重载->操作符  
     {  
         return _ptr;  
     }  
     ~smartpointer()        //析构函数  
     {  
         delete _ptr;  
     }  
 };  

实现引用计数有两种经典策略，在这里将使用其中一种，这里所用的方法中，需要定义一个单独的具体类用以封装引用计数和相关指针：

[cpp]view plaincopy 
   
 // 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针  
 // 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员  
 // 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员  
 class U_Ptr  
 {  
     friend class HasPtr;  
     int *ip;  
     size_t use;  
     U_Ptr(int *p) : ip(p) , use(1)  
     {  
         cout << "U_ptr constructor called !" << endl;  
     }  
     ~U_Ptr()  
     {  
         delete ip;  
         cout << "U_ptr distructor called !" << endl;  
     }  
 };  

HasPtr类需要一个析构函数来删除指针。但是，析构函数不能无条件的删除指针。”
条件就是引用计数。如果该对象被两个指针所指，那么删除其中一个指针，并不会调用该指针的析构函数，因为此时还有另外一个指针指向该对象。看来，智能指针主要是预防不当的析构行为，防止出现悬垂指针。

     如上图所示，HasPtr就是智能指针，U_Ptr为计数器；里面有个变量use和指针ip，use记录了*ip对象被多少个HasPtr对象所指。假设现在又两个HasPtr对象p1、p2指向了U_Ptr，那么现在我delete p1，use变量将自减1， U_Ptr不会析构，那么U_Ptr指向的对象也不会析构，那么p2仍然指向了原来的对象，而不会变成一个悬空指针。当delete p2的时候，use变量将自减1，为0。此时，U_Ptr对象进行析构，那么U_Ptr指向的对象也进行析构，保证不会出现内存泄露。
    包含指针的类需要特别注意复制控制，原因是复制指针时只复制指针中的地址，而不会复制指针指向的对象。
    大多数C++类用三种方法之一管理指针成员
    （1）不管指针成员。复制时只复制指针，不复制指针指向的对象。当其中一个指针把其指向的对象的空间释放后，其它指针都成了悬浮指针。这是一种极端
    （2）当复制的时候，即复制指针，也复制指针指向的对象。这样可能造成空间的浪费。因为指针指向的对象的复制不一定是必要的。
   （3）第三种就是一种折中的方式。利用一个辅助类来管理指针的复制。原来的类中有一个指针指向辅助类，辅助类的数据成员是一个计数器和一个指针（指向原来的）（此为本次智能指针实现方式）。
     其实，智能指针的引用计数类似于java的垃圾回收机制：java的垃圾的判定很简答，如果一个对象没有引用所指，那么该对象为垃圾。系统就可以回收了。
     HasPtr 智能指针的声明如下，保存一个指向U_Ptr对象的指针，U_Ptr对象指向实际的int基础对象，代码如下：

[cpp]view plaincopy 
   
 #include<iostream>  
 using namespace std;  
   
 // 定义仅由HasPtr类使用的U_Ptr类，用于封装使用计数和相关指针  
 // 这个类的所有成员都是private，我们不希望普通用户使用U_Ptr类，所以它没有任何public成员  
 // 将HasPtr类设置为友元，使其成员可以访问U_Ptr的成员  
 class U_Ptr  
 {  
     friend class HasPtr;  
     int *ip;  
     size_t use;  
     U_Ptr(int *p) : ip(p) , use(1)  
     {  
         cout << "U_ptr constructor called !" << endl;  
     }  
     ~U_Ptr()  
     {  
         delete ip;  
         cout << "U_ptr distructor called !" << endl;  
     }  
 };  
   
 class HasPtr  
 {  
 public:  
     // 构造函数：p是指向已经动态创建的int对象指针  
     HasPtr(int *p, int i) : ptr(new U_Ptr(p)) , val(i)  
     {  
         cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;  
     }  
   
     // 复制构造函数：复制成员并将使用计数加1  
     HasPtr(const HasPtr& orig) : ptr(orig.ptr) , val(orig.val)  
     {  
         ++ptr->use;  
         cout << "HasPtr copy constructor called ! " << "use = " << ptr->use << endl;  
     }  
   
     // 赋值操作符  
     HasPtr& operator=(const HasPtr&);  
   
     // 析构函数：如果计数为0，则删除U_Ptr对象  
     ~HasPtr()  
     {  
         cout << "HasPtr distructor called ! " << "use = " << ptr->use << endl;  
         if (--ptr->use == 0)  
             delete ptr;  
     }  
   
     // 获取数据成员  
     int *get_ptr() const  
     {  
         return ptr->ip;  
     }  
     int get_int() const  
     {  
         return val;  
     }  
   
     // 修改数据成员  
     void set_ptr(int *p) const  
     {  
         ptr->ip = p;  
     }  
     void set_int(int i)  
     {  
         val = i;  
     }  
   
     // 返回或修改基础int对象  
     int get_ptr_val() const  
     {  
         return *ptr->ip;  
     }  
     void set_ptr_val(int i)  
     {  
         *ptr->ip = i;  
     }  
 private:  
     U_Ptr *ptr;   //指向使用计数类U_Ptr  
     int val;  
 };  
 HasPtr& HasPtr::operator = (const HasPtr &rhs)  //注意，这里赋值操作符在减少做操作数的使用计数之前使rhs的使用技术加1，从而防止自我赋值  
 {  
     // 增加右操作数中的使用计数  
     ++rhs.ptr->use;  
     // 将左操作数对象的使用计数减1，若该对象的使用计数减至0，则删除该对象  
     if (--ptr->use == 0)  
         delete ptr;  
     ptr = rhs.ptr;   // 复制U_Ptr指针  
     val = rhs.val;   // 复制int成员  
     return *this;  
 }  
   
 int main(void)  
 {  
     int *pi = new int(42);  
     HasPtr *hpa = new HasPtr(pi, 100);    // 构造函数  
     HasPtr *hpb = new HasPtr(*hpa);     // 拷贝构造函数  
     HasPtr *hpc = new HasPtr(*hpb);     // 拷贝构造函数  
     HasPtr hpd = *hpa;     // 拷贝构造函数  
   
     cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;  
     hpc->set_ptr_val(10000);  
     cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;  
     hpd.set_ptr_val(10);  
     cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;  
     delete hpa;  
     delete hpb;  
     delete hpc;  
     cout << hpd.get_ptr_val() << endl;  
     return 0;  
 }  

这里的赋值操作符比较麻烦，且让我用图表分析一番：
假设现在又两个智能指针p1、 p2，一个指向内容为42的内存，一个指向内容为100的内存，如下图：

现在，我要做赋值操作，p2 = p1。对比着上面的

[cpp]view plaincopy 
   
 HasPtr& operator=(const HasPtr&);   // 赋值操作符  

此时，rhs就是p1，首先将p1指向的ptr的use加1，

[cpp]view plaincopy 
   
 ++rhs.ptr->use;     // 增加右操作数中的使用计数  

然后，做：

[cpp]view plaincopy 
   
 if (--ptr->use == 0)  
         delete ptr;  

因为，原先p2指向的对象现在p2不在指向，那么该对象就少了一个指针去指，所以，use做自减1；
此时，条件成立。因为u2的use为1。那么，运行U_Ptr的析构函数，而在U_Ptr的析构函数中，做了delete ip操作，所以释放了内存，不会有内存泄露的问题。
接下来的操作很自然，无需多言：

[cpp]view plaincopy 
   
 ptr = rhs.ptr;   // 复制U_Ptr指针  
     val = rhs.val;   // 复制int成员  
     return *this;  

做完赋值操作后，那么就成为如下图所示了。红色标注的就是变化的部分：

而还要注意的是，重载赋值操作符的时候，一定要注意的是，检查自我赋值的情况。
如图所示：

此时，做p1 = p1的操作。那么，首先u1.use自增1，为2；然后，u1.use自减1，为1。那么就不会执行delete操作，剩下的操作都可以顺利进行。按《C++ primer》说法，“这个赋值操作符在减少左操作数的使用计数之前使rhs的使用计数加1，从而防止自身赋值”。哎，反正我是那样理解的。当然，赋值操作符函数中一来就可以按常规那样：

[cpp]view plaincopy 
   
 if(this == &rhs)  
         return *this;  

运行结果如下图：

转载出处http://www.cnblogs.com/TianFang/archive/2008/09/19/1294521.html
Boost智能指针——shared_ptr

boost::scoped_ptr虽然简单易用，但它不能共享所有权的特性却大大限制了其使用范围，而boost::shared_ptr可以解决这一局限。顾名思义，boost::shared_ptr是可以共享所有权的智能指针，首先让我们通过一个例子看看它的基本用法：

#include <string>
#include <iostream>
#include <boost/shared_ptr.hpp>

class implementation
{
public:
    ~implementation() { std::cout <<"destroying implementation\n"; }
    void do_something() { std::cout << "did something\n"; }
};

void test()
{
    boost::shared_ptr<implementation> sp1(new implementation());
    std::cout<<"The Sample now has "<<sp1.use_count()<<" references\n";

    boost::shared_ptr<implementation> sp2 = sp1;
    std::cout<<"The Sample now has "<<sp2.use_count()<<" references\n";

    sp1.reset();
    std::cout<<"After Reset sp1. The Sample now has "<<sp2.use_count()<<" references\n";

    sp2.reset();
    std::cout<<"After Reset sp2.\n";
}

void main()
{
    test();
}

该程序的输出结果如下：

The Sample now has 1 references
The Sample now has 2 references
After Reset sp1. The Sample now has 1 references
destroying implementation
After Reset sp2.

可以看到，boost::shared_ptr指针sp1和sp2同时拥有了implementation对象的访问权限，且当sp1和sp2都释放对该对象的所有权时，其所管理的的对象的内存才被自动释放。在共享对象的访问权限同时，也实现了其内存的自动管理。

boost::shared_ptr的内存管理机制：

boost::shared_ptr的管理机制其实并不复杂，就是对所管理的对象进行了引用计数，当新增一个boost::shared_ptr对该对象进行管理时，就将该对象的引用计数加一；减少一个boost::shared_ptr对该对象进行管理时，就将该对象的引用计数减一，如果该对象的引用计数为0的时候，说明没有任何指针对其管理，才调用delete释放其所占的内存。

上面的那个例子可以的图示如下：

sp1对implementation对象进行管理，其引用计数为1
增加sp2对implementation对象进行管理，其引用计数增加为2
sp1释放对implementation对象进行管理，其引用计数变为1
sp2释放对implementation对象进行管理，其引用计数变为0，该对象被自动删除

boost::shared_ptr的特点：

和前面介绍的boost::scoped_ptr相比，boost::shared_ptr可以共享对象的所有权，因此其使用范围基本上没有什么限制（还是有一些需要遵循的使用规则，下文中介绍），自然也可以使用在stl的容器中。另外它还是线程安全的，这点在多线程程序中也非常重要。

转自http://www.tuicool.com/articles/Ff2M3m7

使用 boost::shared_ptr的注意事项

(1) 不要把一个原生指针给多个shared_ptr管理

int* ptr = new int;
boost::shared_ptr<int> p1(ptr);
boost::shared_ptr<int> p2(ptr);

这样做会导致ptr会被释放两次。在实际应用中，保证除了第一个shared_ptr使用ptr定义之外，后面的都采用p1来操作，就不会出现此类问题。

(2) 不要在函数实参里创建shared_ptr

function(shared_ptr<int>(new int), g());  //有缺陷
    //可能的过程是先new int，然后调g()，g()发生异常，shared_ptr<int>没有创建，int内存泄露
    //推荐写法
    shared_ptr<int> p(new int());
    f(p, g());

(3) shared_ptr作为被保护的对象的成员时，小心因循环引用造成无法释放资源。

简单的例子：

class parent;
class children;
typedef boost::shared_ptr<parent> parent_ptr;
typedef boost::shared_ptr<children> children_ptr;

class parent {
public:
    children_ptr children;
};

class children {public:
    parent_ptr parent;
};
void test()
{
    boost::shared_ptr<parent> father( new parent);
    boost::shared_ptr<children> son(new children);
    father->children = son;　　//user_count() == 2
    son->parent = father;　　//user_count() == 2
}

在这个例子中，出现了循环引用计数，赋值后use_count()变为2，出函数后变为1，资源无法被释放。boost的解决方法是采用 weak_ptr来保存。

class parent {public:
   boost::weak_ptr<children> children;
};

class children {public:
     boost::weak_ptr<father> parent;
};

因为boost不会影响weak_ptr不会影响引用计数，不会造成循环引用计数。

(4) 不要把this指针给shared_ptr

将this指针赋给shared_ptr会出现this指针被释放两次的危险，如下面的代码，会在t释放时析构一次，shared_ptr释放时析构一次。

class test {
  public:
    boost::shared_ptr<test> pget() {
      return boost::shared_ptr<test>(this);
  }        
};

test t;
boost::shared_ptr<test> pt = t.pget();

boost库提供的解决方法是：使用enable_shared_from_this来实现。

class test : public boost::enable_shared_from_this<test> {
  public:
    boost::shared_ptr<test> pget() {
      return shared_from_this();
  }        
};

test t;
boost::shared_ptr<test> pt = t.pget();