刘森林l的博客

Coredump文件是什么？1.1 产生根因1.2 如何打开？1.3 如何设置文件名以及路径GDB理论部分2.1 基本命令2.2 被忽略但实用的命令2.3 实用的GDB设置GDB操作部分3.1 coredump文件是否任何时候都产生？3.2 系统函数是否可以打印coredump信息？3.3 调试案列（基本使用）3.4 调试案列（多进程）3.5 调试案列（多线程以及线程锁问...

this指针的用处:　　一个对象的this指针并不是对象本身的一部分，不会影响sizeof(对象)的结果。this作用域是在类内部，当在类的非静态成员函数中访问类的非静态成员的时候，编译器会自动将对象本身的地址作为一个隐含参数传递给函数。也就是说，即使你没有写上this指针，编译器在编译的时候也是加上this的，它作为非静态成员函数的隐含形参，对各成员的访问均通过this进行。 　　例如，调用dat

#include#include#includeusing namespace std;class Test {public: void show(void) { cout <<data<< endl; }public: Test(char *str = "") { if(str == '\0'){ data = (char *)mall

　　多态性可以简单地概括为“一个接口，多种方法”，程序在运行时才决定调用的函数，它是面向对象编程领域的核心概念。多态(polymorphism)，字面意思多种形状。在C++中有两种多态性 ：      1.编译时的多态性-----通过函数的重载和运算符的重载来实现的      2.运行时的多态性-----运行时的多态性是指在程序执行前，无法根据函数名和参数来确定该调用哪

假设我们有这样的一个类： class Base {     public:            virtual void f() { cout  "Base::f" << endl; }            virtual void g() { cout  "Base::g" << endl; }            virtual void h()

一、基本概念1、类的继承，是新的类从已有类那里得到已有的特性。或从已有类产生新类的过程就是类的派生。原有的类称为基类或父类，产生的新类称为派生类或子类。 2、派生类的声明：class 派生类名：继承方式 基类名1， 继承方式 基类名2，...，继承方式 基类名n{    派生类成员声明；}; 3、一个派生类可以同时有多个基类，这种情况称为多重继承，派生类

C++中，比较类的三种继承方式：共有继承、受保护继承、私有继承之间的区别在三种不同方式的继承下，派生类对原来基类中的成员访问的方式也不一样，具体如下： 1>公有继承中： （1）基类的共有成员就相当于是派生类的公有成员，也就是说派生类可以像访问自身公有成员一样访问从基类继承的公有成员。 （2）基类的保护成员就相当于是派生类的保护成员，即，派生类可以像访问自

继承（inheritance）机制        是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构。体现了由简单到复杂的认识过程。 思想：        从现有的类继承属性和行为，然后增加属性和行为定制类以满足我们的实际要求，创建派生类不会英系那个基类的

虚基类共同基类设置为虚基类，这样从不同路径继承来的同名数据成员在内存中就只有一个拷贝，同名函数也只有一种映射虚基类（virtual base class）定义方式如下：class 派生类名:virtual  访问限定符  基类类名{...};class 派生类名:访问限定符  virtual  基类类名{...};virtual 关键字只对紧随其后的基类名起作用

http://blog.csdn.net/wangxingbao4227/article/details/6772579C++中虚拟继承的概念为了解决从不同途径继承来的同名的数据成员在内存中有不同的拷贝造成数据不一致问题，将共同基类设置为虚基类。这时从不同的路径继承过来的同名数据成员在内存中就只有一个拷贝，同一个函数名也只有一个映射。这样不仅就解决了二义性问题，也节省了内存，避

C++中的容器类包括“顺序存储结构”和“关联存储结构”，前者包括vector，list，deque等；后者包括set，map，multiset，multimap等。若需要存储的元素数在编译器间就可以确定，可以使用数组来存储，否则，就需要用到容器类了。1、vector    连续存储结构，每个元素在内存上是连续的；    支持高效的随机访问和在尾端插入/删除操作，但其

#include#includeusing namespace std;class my_complex{public: //关系运算符重载 bool operator == (const A& ); bool operator != (const A& ); bool operator < (c

c++的一大特性就是重载(overload)，通过重载可以把功能相似的几个函数合为一个，使得程序更加简洁、高效。在c++中不止函数可以重载，运算符也可以重载。由于一般数据类型间的运算符没有重载的必要，所以运算符重载主要是面向对象之间的。1.一般运算符重载在进行对象之间的运算时，程序会调用与运算符相对应的函数进行处理，所以运算符重载有两种方式：成员函数和友元函数。成员函数的形

关于c++ new操作符的重载你知道c++ 的new 操作符和operator new 的区别么？也许你还会问，他们有区别吗？ 当你写下面这样的代码时，string *pa = new string("memory managerment");你使用的是new 操作符，这个操作符和sizeof 一样，是c++ 语言级别支持的。你不能改变它的语义，它做的事情总是不变的：分

#include#includeusing namespace std;class my_complex{public: my_complex& operator ++ ();//前置++ my_complex& operator ++ (int);//后置++public: //单目运算符重载

#include#include#include#include#includeusing namespace std;class my_complex{public:void * operator new(size_t size){ void *p = (void *)malloc(size); if(NULL != p) { cout <

#include<iostream>#include<stdio.h>using namespace std;class TEST{ public: TEST &fun(TEST sd) { int temp; temp = sd.get_data() ; TEST

new 和 delete 到底是什么？如果找工作的同学看一些面试的书，我相信都会遇到这样的题：sizeof 不是函数，然后举出一堆的理由来证明 sizeof 不是函数。在这里，和 sizeof 类似，new 和 delete 也不是函数，它们都是 C++ 定义的关键字，通过特定的语法可以组成表达式。和 sizeof 不同的是，sizeof 在编译时候就可以确定其返回值，new 和 de

静态存储分配：通常定义变量（或对象），编译器在编译时都可以根据该变量（或对象）的类型知道所需内存空间的大小，从而系统在适当的时候为他们分配确定的存储空间动态存储分配：有些操作对象只有在程序运行时才能确定，这样编译器在编译时就无法为他们预定存储空间，只能在程序运行时，系统根据运行时的要求进行内存分配。所有动态存储分配都在堆区中进行堆分配：当程序运行到需

#includeusing namespace std;int main(int argc, char *argv[] ){    struct                             //C++可以有空结构体，在G++编译器定义为1字节    {    } my_student ;    cout     cout

类是把函数和一些成员数据放在一起，类似于结构体struct。 声明格式是 class+类名 { 数据成员 +成员函数 } 。 class 是必须的关键词。 对象就是把 “类” 实例化 ，也类似于结构体变量的声明，它的创建格式是 类名+对象名，比如有一个已经定义的类 A ，可以这样把A实例化 A a ; a就是你创建的对象。只有创建了对象，类才能发挥作用。在C++中，类是一种数据类型

#include<iostream>using namespace std; class test { public:/* 构造函数 **************/ test() { } test(int a,short id) {

构造函数的定义与使用构造函数是特殊的公有成员函数，其特征如下：1.函数名与类名相同。2.构造函数无函数返回类型说明。注意是没有而不是void，即什么也不写，也不可写void！实际上构造函数有返回值，返回的就是构造函数所创建的对象，见5.5节。3.在程序运行时，当新的对象被建立，该对象所属的类的构造函数自动被调用，在该对象生存期中也只调用这一次。4.构造函数可

#include<iostream>#include<stdio.h>using namespace std;int main(){ char str[]="hello"; cout << sizeof(str)<<endl; //数组名代表整个数组的大小，值为首元素的地址 char ds[5][5] ={"hell","jin"};//与上同理 c

指针: 指针就是地址，指针值就是地址值。指针变量就是存放指针的变量，所以一定不要将指针与指针变量搞混淆了。指针仅仅是一个地址值，而指针变量就是存放指针(也就是地址的变量)指针的定义:例如整型指针: int *p;p是一个指向int类型数据的指针变量。里面存放的地址(也就是指针)是一个int类型变量的地址。指针变量时有类型的，例如p

 一．指针与数组的联系：指针与数组是C语言中很重要的两个概念，它们之间有着密切的关系，利用这种关系，可以增强处理数组的灵活性，加快运行速度，本文着重讨论指针与数组之间的联系及在编程中的应用。1．指针与数组的关系　　当一个指针变量被初始化成数组名时，就说该指针变量指向了数组。如：　　char str[20], *ptr;　　ptr=str;　　ptr被置为数组st

指针数组：array of pointers，即用于存储指针的数组，也就是数组元素都是指针数组指针：a pointer to an array，即指向数组的指针还要注意的是他们用法的区别，下面举例说明。int* a[4]     指针数组                      表示：数组a中的元素都为int型指针                     元素

看了一些资料，指向二维数组的指针定义方式并不是直接定义指针的指针int   a[3][6];int **p=a;        像这样定义是错误的因为a代表着除了第一列以外的列数的维数大小，如a+1的地址就是a[1]的地址，也就是a[1][0]的地址，而p仅是整形指针的指针，没跨越一次就是4字节，因此他们的大小是不匹配的，所以这样子直接等于号是不正确的。要真正的定义方式应概

          1.C++中预定义的运算符的操作对象只能是基本数据类型。但实际上，对于许多用户自定义类型（例如类），也需要类似的运算操作。这时就必须在C++中重新定义这些运算符，赋予已有运算符新的功能，使它能够用于特定类型执行特定的操作。运算符重载的实质是函数重载，它提供了C++的可扩展性，也是C++最吸引人的特性之一           2.运算符重载是通过创建运算符函数实现的，

友元函数的例子：#include#includeusing namespace std;class point { friend void show(point & ); public: point() {} point(int x,int y):x(x),y(y) {} point (point &sd) {

友元函数一个常规的成员函数声明描述了三件在逻辑上相互不同的事情1.  该函数能访问类声明的私用部分2.  该函数位于类的作用域之中3.  该函数必须经由一个对象去激活（有一个this指针）   通过将函数声明为友元函数1.  则 2，3条件失效，2.

static 函数小结#include<iostream>#include<stdio.h>using namespace std;class point { public: void show(void) //普通方法可以访问访问static data { cout << "x = "<< x <<en

为什么要引入模板？1.   为了代码重用，代码就必须是通用的；通用的代码就必须不受数据类型的限制。那么我们可以把数据类型改为一个设计参数。这种类型的程序设计称为参数化(parameterize) 程序设计。2.用普通函数来实现抽象操作会迫使你定义多个函数实例，从而招致不小的维护工作和调试开销。解决办法是使用函数模板代替普通函数。分类：包括：函数模板(function

类模板的定义：如同函数模板一样，使用类模板使用户可以为类定义一种模式，使得类中的某些数据成员、某些成员函数的参数、某些成员函数的返回值能取任意类型。类模板是对一批仅仅成员数据类型不同的类的抽象，程序员只要为这一批类所组成的整个类家族创建一个类模板，给出一套程序代码，就可以用来生成多种具体的类，(这类可以看作是类模板的实例)，从而大大提高编程的效率。定义类模板的一般形式是：　

#includeusing std ::cout;using std ::string;using std ::cin;using std ::endl;int main (int argc, char **argv){ // const int i; //错误：常量必须初始化 int b = 9; // const int i = 8; /