关闭

c++简单整理

标签: c++基础
573人阅读 评论(0) 收藏 举报
分类:

最近一直在学c++编程的知识,初识c++做个简单整理

基础

初步了解cpp

cpp 可以看做是对象的集合

对象,类,方法,临时变量

代码的非面向对象部分和c类似

cpp支持命名空间 例如:use namespace std;

编译 g++ hi.cpp

特性三字符组

??=     #
??/     \
??'     ^
??(     [
??)     ]
??!     |
??<     {
??>     }
??-     ~

注释 略

基础数据类型

内置类型

布尔型 bool
字符型 char
整型  int
浮点型 float
双浮点型    double
无类型 void
宽字符型    wchar_t

类型允许的修饰符 signed unsigned short long

注意数据类型的表示范围

endl换行符

typeof 与c相同

enum 与c相同

变量的声明与c相同

变量的作用域与c相同

常量的定义与c相同

修饰符的类型与c相同

数据修饰符:signed unsigned long short
const   const 类型的对象在程序执行期间不能被修改改变。
volatile    修饰符 volatile 告诉编译器,变量的值可能以程序未明确指定的方式被改变。
restrict    由 restrict 修饰的指针是唯一一种访问它所指向的对象的方式。
            只有 C99 增加了新的类型限定符 restrict。

存储类型

auto 存储类是所有局部变量默认的存储类。
register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小(通常是一个词),且不能对它应用一元的 '&' 运算符(因为它没有内存位置)。
static  存储类指示编译器在程序的生命周期内保持局部变量的存在,
          而不需要在每次它进入和离开作用域时进行创建和销毁。
extern  存储类用于提供一个全局变量的引用,全局变量对所有的程序文件都是可见的。
mutable mutable 说明符仅适用于类的对象,它允许对象的成员替代常量。也就是说,
        mutable 成员可以通过 const 成员函数修改。

运算符与c相同

循环与c相同

判断与c相同

函数与c相同,也有不同的地方

定义函数:return_type function_name( parameter list )
支持传值调用 void swap(int a,int b);
支持指针调用 void swap(int *a,int *b);
支持引用调用 void swap(int &a,int &b);
参数的默认值 int sum(int a ,int b=2)

数字的类型与c相同

数字:short s; int i;long l;float f;double d;

数学运算

使用头文件<cmath.h>
    srand((unsiged)time(NULL)),rand

数组和c相同

定义数组    type arrayName [ arraySize ];
初始化数组 ,访问数组
多维数组
指向数组的指针
该函数传递数组三种方式:func1(int *a),func2(int a[n]),func3(int a[]);
从函数返回数组

字符串

c风格的字符串 字符和\0结尾表示字符串,cstring调用c的函数

指针和c相同

支持NULL指针
支持算术运算
支持在数组中使用
也支持指针数组
支持指向指针的指针
函数传递指针
从函数返回指针

引用

引用和指针的不同
        不存在空引用。引用必须连接到一块合法的内存。
        一旦引用被初始化为一个对象,就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
        引用必须在创建时被初始化。指针可以在任何时间被初始化
引用的用处
    可以作为参数
    可以作为返回值

时间和日期(参考c的日期的使用)

主要是使用c的日期   <ctime>
    struct tm {
                  int tm_sec;   // 秒,正常范围从 0 到 59,但允许至 61
                  int tm_min;   // 分,范围从 0 到 59
                  int tm_hour;  // 小时,范围从 0 到 23
                  int tm_mday;  // 一月中的第几天,范围从 1 到 31
                  int tm_mon;   // 月,范围从 0 到 11
                  int tm_year;  // 自 1900 年起的年数
                  int tm_wday;  // 一周中的第几天,范围从 0 到 6,从星期日算起
                  int tm_yday;  // 一年中的第几天,范围从 0 到 365,从 1 月 1 日算起
                  int tm_isdst; // 夏令时
                }

基本的输入和输出

iostream 该文件定义了 cin、cout、cerr 和 clog 对象,
            分别对应于标准输入流、标准输出流、非缓冲标准错误流和缓冲标准错误流。
iomanip 该文件通过所谓的参数化的流操纵器(比如 setw 和 setprecision),
            来声明对执行标准化 I/O 有用的服务。
fstream 该文件为用户控制的文件处理声明服务。我们将在文件和流的相关章节讨论它的细节。

数据结构与c相同

面向对象基础

类和对象

定义变量

定义方法可以和声明分开,这点很有意思哦 分开定义的时候使用::去使用函数,比如 A::func1

支持三种权限控制 public、private、protected 和其他语言没什么区别

构造函数和析构函数和其他语言很像,也可以设置默认值,语法有点不同

 例如Box类定义三个变量    double length;double breadth;double height;
 Box类初始化列表可以是  Box::Box(double len,double bre,double hei):length(len),breadth(bre),height(hei)
 很神奇是不是?

拷贝构造函数。所有涉及到类的拷贝的地方可能都需要用到它,你需要注意这一点。

1 创建一个新的对象
2 类内部带有指针的变量

拷贝构造函数是一种特殊的构造函数,它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象。
拷贝构造函数通常用于:
    通过使用另一个同类型的对象来初始化新创建的对象。
    复制对象把它作为参数传递给函数。
    复制对象,并从函数返回这个对象。
如果在类中没有定义拷贝构造函数,编译器会自行定义一个。
如果类带有指针变量,并有动态内存分配,则它必须有一个拷贝构造函数。

友元函数,友元类,这个比较特别,java的内部类是不是参照这个来的。

类的友元函数是定义在类外部,但有权访问类的所有私有(private)成员和保护(protected)成员。
尽管友元函数的原型有在类的定义中出现过,但是友元函数并不是成员函数。

内联函数

C++ 内联函数是通常与类一起使用。如果一个函数是内联的,那么在编译时,
编译器会把该函数的代码副本放置在每个调用该函数的地方。

this指针 代表当前对象

指向类的指针,指针的用途和c类似

静态成员:属性和方法

我们可以使用 static 关键字来把类成员定义为静态的。当我们声明类的成员为静态时,这意味着无论创建多少个类的对象,静态成员都只有一个副本。
静态成员在类的所有对象中是共享的。如果不存在其他的初始化语句,在创建第一个对象时,所有的静态数据都会被初始化为零。
我们不能把静态成员放置在类的定义中,但是可以在类的外部通过使用范围解析运算符 :: 来重新声明静态变量从而对它进行初始化,如下面的实例所示。

特别的继承

继承的定义:
    已有的类称为基类,新建的类称为派生类。
    继承代表了 is a 关系。

继承的语法:
    class derived-class: access-specifier base-class
    访问修饰符 access-specifier 是 public、protected 或 private 其中的一个,
    base-class 是之前定义过的某个类的名称。

public 所有类可访问,protected子类可以访问,private 私有类可以访问

继承方式
        公有继承(public):当一个类派生自公有基类时,基类的公有成员也是派生类的公有成员,
                            基类的保护成员也是派生类的保护成员,基类的私有成员不能直接被派生类访问,
                            但是可以通过调用基类的公有和保护成员来访问。
        保护继承(protected): 
                        当一个类派生自保护基类时,基类的公有和保护成员将成为派生类的保护成员。
                        基类的共有和保护成为派生的保护成员
        私有继承(private):
                        当一个类派生自私有基类时,基类的公有和保护成员将成为派生类的私有成员。
                        父类的修饰符不变
                        基类的共有和保护成为派生的私有成员


不继承什么:一个派生类继承了所有的基类方法,但下列情况除外:
    基类的构造函数、析构函数和拷贝构造函数。
    基类的重载运算符。
    基类的友元函数。

支持多继承
    class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…

重载运算符和重载函数

重载的意义:高效,多态
C++ 允许在同一作用域中的某个函数和运算符指定多个定义,分别称为函数重载和运算符重载。
操作符重载类似这种:
    Box operator+(const Box& b);

多态

默认的是静态多态,或静态链接 - 函数调用在程序执行前就准备好了。
有时候这也被称为早绑定,因为 area() 函数在程序编译期间就已经设置好了。
需要使用vitual关键字

虚函数
    虚函数 是在基类中使用关键字 virtual 声明的函数。
    在派生类中重新定义基类中定义的虚函数时,会告诉编译器不要静态链接到该函数。
    我们想要的是在程序中任意点可以根据所调用的对象类型来选择调用的函数,
    这种操作被称为动态链接,或后期绑定。

纯虚函数
    您可能想要在基类中定义虚函数,以便在派生类中重新定义该函数更好地适用于对象,
    但是您在基类中又不能对虚函数给出有意义的实现,这个时候就会用到纯虚函数。

抽象和封装–类和访问权限修饰符就是干这个事情的

接口 –通过纯虚函数来实现

接口描述了类的行为和功能,而不需要完成类的特定实现。
C++ 接口是使用抽象类来实现的,抽象类与数据抽象互不混淆,
数据抽象是一个把实现细节与相关的数据分离开的概念。
如果类中至少有一个函数被声明为纯虚函数,则这个类就是抽象类。
纯虚函数是通过在声明中使用 "= 0" 来指定的,如下所示:

类的生命周期

设类A
    1.栈内对象: {A x;}的}结束处,对象即结束生命
    2.堆对象:  A *p=new A;  当程序员调用delete p时才结束生命,否则程序运行时一直存在
    3.静态存储区对象: 如全局对象和局部的静态对象,生命期是程序开始一直到结束

cpp的文件和流

ofstream    该数据类型表示输出文件流,用于创建文件并向文件写入信息。
ifstream    该数据类型表示输入文件流,用于从文件读取信息。
fstream 该数据类型通常表示文件流,且同时具有 ofstream 和 ifstream 两种功能,
        这意味着它可以创建文件,向文件写入信息,从文件读取信息。

open函数
void open(const char *filename, ios::openmode mode);
在这里,open() 成员函数的第一参数指定要打开的文件的名称和位置,第二个参数定义文件被打开的模式。
模式标志    描述
    ios::app    追加模式。所有写入都追加到文件末尾。
    ios::ate    文件打开后定位到文件末尾。
    ios::in 打开文件用于读取。
    ios::out    打开文件用于写入。
    ios::trunc  如果该文件已经存在,其内容将在打开文件之前被截断,即把文件长度设为 0。
void close();
写入文件
        在 C++ 编程中,我们使用流插入运算符( << )向文件写入信息,
        就像使用该运算符输出信息到屏幕上一样。唯一不同的是,
        在这里您使用的是 ofstream 或 fstream 对象,而不是 cout 对象。
读取文件
    在 C++ 编程中,我们使用流提取运算符( >> )从文件读取信息,
    就像使用该运算符从键盘输入信息一样。唯一不同的是,在这里您使用的是 ifstream 或 fstream 对象,
    而不是 cin 对象。
文件的位置
    文件位置指针
    istream 和 ostream 都提供了用于重新定位文件位置指针的成员函数。
        这些成员函数包括关于 istream 的 seekg("seek get")
        和关于 ostream 的 seekp("seek put")。
    seekg 和 seekp 的参数通常是一个长整型。
        第二个参数可以用于指定查找方向。查找方向可以是 ios::beg(默认的,从流的开头开始定位),
            也可以是 ios::cur(从流的当前位置开始定位),也可以是 ios::end(从流的末尾开始定位)。
    文件位置指针是一个整数值,指定了从文件的起始位置到指针所在位置的字节数。
        下面是关于定位 "get" 文件位置指针的实例:
    // 定位到 fileObject 的第 n 个字节(假设是 ios::beg)
    fileObject.seekg( n );

    // 把文件的读指针从 fileObject 当前位置向后移 n 个字节
    fileObject.seekg( n, ios::cur );

    // 把文件的读指针从 fileObject 末尾往回移 n 个字节
    fileObject.seekg( n, ios::end );

    // 定位到 fileObject 的末尾
    fileObject.seekg( 0, ios::end );

异常处理

异常是程序在执行期间产生的问题。C++ 异常是指在程序运行时发生的特殊情况,比如尝试除以零的操作。
异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字:try、catch、throw。
    throw: 当问题出现时,程序会抛出一个异常。这是通过使用 throw 关键字来完成的。
    catch: 在您想要处理问题的地方,通过异常处理程序捕获异常。catch 关键字用于捕获异常。
    try: try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块。

标准异常

异常分类
    std::exception  该异常是所有标准 C++ 异常的父类。
    std::bad_alloc  该异常可以通过 new 抛出。
    std::bad_cast   该异常可以通过 dynamic_cast 抛出。
    std::bad_exception  这在处理 C++ 程序中无法预期的异常时非常有用。
    std::bad_typeid 该异常可以通过 typeid 抛出。
    std::logic_error    理论上可以通过读取代码来检测到的异常。
    std::domain_error   当使用了一个无效的数学域时,会抛出该异常。
    std::invalid_argument   当使用了无效的参数时,会抛出该异常。
    std::length_error   当创建了太长的 std::string 时,会抛出该异常。
    std::out_of_range   该异常可以通过方法抛出,例如 std::vector 和
                             std::bitset<>::operator[]()。
    std::runtime_error  理论上不可以通过读取代码来检测到的异常。
    std::overflow_error 当发生数学上溢时,会抛出该异常。
    std::range_error    当尝试存储超出范围的值时,会抛出该异常。
    std::underflow_error    当发生数学下溢时,会抛出该异常。
定义自己的异常
    struct MyException : public exception{}
在这里,what() 是异常类提供的一个公共方法,它已被所有子异常类重载。这将返回异常产生的原因。

动态内存

栈:在函数内部声明的所有变量都将占用栈内存。
堆:这是程序中未使用的内存,在程序运行时可用于动态分配内存。

在 C++ 中,您可以使用特殊的运算符为给定类型的变量在运行时分配堆内的内存,这会返回所分配的空间地址。
这种运算符即 new 运算符。
如果您不需要动态分配内存,可以使用 delete 运算符,删除之前由 new 运算符分配的内存。

malloc() 函数在 C 语言中就出现了,在 C++ 中仍然存在,
    但建议尽量不要使用 malloc() 函数。new 与 malloc() 函数相比,
    其主要的优点是,new 不只是分配了内存,它还创建了对象。

命名空间

命名空间这个概念,专门用于解决上面的问题,
它可作为附加信息来区分不同库中相同名称的函数、类、变量等。
使用了命名空间即定义了上下文。本质上,命名空间就是定义了一个范围。

定义命名空间
    namespace secondSpace{}
使用命名空间
    using namespace firstSpace;
    使用命名空间的方法
        thirdSpace::fourth::func2();
嵌套命名空间
    using namespace firstSpace:thirdSpace;

预处理器-与c相同

预处理#define PI 3.14159
函数宏 #define MIN(a,b) (((a)<(b)) ? a : b)
条件编译
    #ifndef NULL
       #define NULL 0
    #endif
# 和 ## 运算符
    # 和 ## 预处理运算符在 C++ 和 ANSI/ISO C 中都是可用的。
    # 运算符会把 replacement-text 令牌转换为用引号引起来的字符串。

预定义宏
    __LINE__    这会在程序编译时包含当前行号。
    __FILE__    这会在程序编译时包含当前文件名。
    __DATE__    这会包含一个形式为 month/day/year 的字符串,它表示把源文件转换为目标代码的日期。
    __TIME__    这会包含一个形式为 hour:minute:second 的字符串,它表示程序被编译的时间。

模板

定义  
    模板是泛型编程的基础,泛型编程即以一种独立于任何特定类型的方式编写代码。
    模板是创建泛型类或函数的蓝图或公式。
        库容器,比如迭代器和算法,都是泛型编程的例子,它们都使用了模板的概念。
    每个容器都有一个单一的定义,比如 向量,我们可以定义许多不同类型的向量,
        比如 vector <int> 或 vector <string>。
模板函数
    template <class type> ret-type func-name(parameter list){}  

模板类
    template <class type> class class-name {}
    template<class T> class Stack{

    }

信号处理(调用系统的信号处理)

信号说明
    信号是由操作系统传给进程的中断,会提早终止一个程序。
    在 UNIX、LINUX、Mac OS X 或 Windows 系统上,可以通过按 Ctrl+C 产生中断。
    有些信号不能被程序捕获,但是下表所列信号可以在程序中捕获,
    并可以基于信号采取适当的动作。这些信号是定义在 C++ 头文件 <csignal> 中。

常用信号
        信号  描述
        SIGABRT 程序的异常终止,如调用 abort。
        SIGFPE  错误的算术运算,比如除以零或导致溢出的操作。
        SIGILL  检测非法指令。
        SIGINT  接收到交互注意信号。
        SIGSEGV 非法访问内存。
        SIGTERM 发送到程序的终止请求。
signal函数
    void (*signal (int sig, void (*func)(int)))(int); 
raise() 函数
    int raise (signal sig);

多线程

多线程说明:

    多线程是多任务处理的一种特殊形式,多任务处理允许让电脑同时运行两个或两个以上的程序。
    一般情况下,两种类型的多任务处理:基于进程和基于线程。
        基于进程的多任务处理是程序的并发执行。
        基于线程的多任务处理是同一程序的片段的并发执行。
    多线程程序包含可以同时运行的两个或多个部分。
    这样的程序中的每个部分称为一个线程,每个线程定义了一个单独的执行路径。
    C++ 不包含多线程应用程序的任何内置支持。相反,它完全依赖于操作系统来提供此功能。
    本教程假设您使用的是 Linux 操作系统,我们要使用 POSIX 编写多线程 C++ 程序。
    POSIX Threads 或 Pthreads 提供的 API 可在多种类 Unix POSIX 系统上可用,
    比如 FreeBSD、NetBSD、GNU/Linux、Mac OS X 和 Solaris。

多线程的函数

多线程的使用

    创建线程
        下面的程序,我们可以用它来创建一个 POSIX 线程:
        #include <pthread.h>
        pthread_create (thread, attr, start_routine, arg) 
        在这里,pthread_create 创建一个新的线程,并让它可执行。下面是关于参数的说明:
        参数  描述
        thread  指向线程标识符指针。
        attr    一个不透明的属性对象,可以被用来设置线程属性。您可以指定线程属性对象,
                也可以使用默认值 NULL。
        start_routine   线程运行函数起始地址,一旦线程被创建就会执行。
        arg 运行函数的参数。它必须通过把引用作为指针强制转换为 void 类型进行传递。
                如果没有传递参数,则使用 NULL。
            创建线程成功时,函数返回 0,若返回值不为 0 则说明创建线程失败。

    终止线程

    pthread_exit (status) 
        在这里,pthread_exit 用于显式地退出一个线程。
        通常情况下,pthread_exit() 函数是在线程完成工作后无需继续存在时被调用。
        如果 main() 是在它所创建的线程之前结束,并通过 pthread_exit() 退出,
        那么其他线程将继续执行。否则,它们将在 main() 结束时自动被终止。
        使用 -lpthread 库编译下面的程序:
        $ g++ test.cpp -lpthread -o test.o 编译多线程程序
    连接和分离线程
        我们可以使用以下两个函数来连接或分离线程:
        pthread_join (threadid, status) 
        pthread_detach (threadid) 
        pthread_join() 子程序阻碍调用程序,直到指定的 threadid 线程终止为止。
        当创建一个线程时,它的某个属性会定义它是否是可连接的(joinable)或可分离的(detached)。
        只有创建时定义为可连接的线程才可以被连接。如果线程创建时被定义为可分离的,则它永远也不能被连接。

cpp web编程,略

STL
简介

    在前面的章节中,我们已经学习了 C++ 模板的概念。C++ STL(标准模板库)
    是一套功能强大的 C++ 模板类,提
    供了通用的模板类和函数,这些模板类和函数可以实现多种流行和常用的算法和数据结构,
    如向量、链表、队列、栈。


C++ 标准模板库的核心包括以下三个组件:
    容器(Containers)  容器是用来管理某一类对象的集合。
    C++ 提供了各种不同类型的容器,比如 deque、list、vector、map 等。
算法(Algorithms)  算法作用于容器。它们提供了执行各种操作的方式,
    包括对容器内容执行初始化、排序、搜索和转换等操作。
迭代器(iterators)  迭代器用于遍历对象集合的元素。这些集合可能是容器,也可能是容器的子集。
这三个组件都带有丰富的预定义函数,帮助我们通过简单的方式处理复杂的任务。
下面的程序演示了向量容器(一个 C++ 标准的模板),它与数组十分相似,唯一不同的是,
向量在需要扩展大小的时候,会自动处理它自己的存储需求:尾的迭代器。

c++标准库的支持

C++ 标准库可以分为两部分:
    标准函数库: 这个库是由通用的、独立的、不属于任何类的函数组成的。函数库继承自 C 语言。
    面向对象类库: 这个库是类及其相关函数的集合。
C++ 标准库包含了所有的 C 标准库,为了支持类型安全,做了一定的添加和修改。
标准函数库
    标准函数库分为以下几类:
        输入/输出 I/O
        字符串和字符处理
        数学
        时间、日期和本地化
        动态分配
        其他
        宽字符函数
面向对象类库
标准的 C++ 面向对象类库定义了大量支持一些常见操作的类,比如输入/输出 I/O、字符串处理、数值处理。
面向对象类库包含以下内容:
标准的 C++ I/O 类
    String 类
    数值类
    STL 容器类
    STL 算法
    STL 函数对象
    STL 迭代器
    STL 分配器
    本地化库
    异常处理类
    杂项支持库   
/**
                c++运算
             **/
            #include <iostream>
            #include <iomanip>
            #include <fstream>
            #include <string>
            #include <cmath>
            #include <cstdlib>
            #include <cstring>
            #include <ctime>
            #include <string>
            #include <csignal>
            #include <unistd.h>
            #include <pthread.h>
            #include <vector>

            #include "basic_syntax.h"

            #define NUM_THREADS 5

            using namespace std;
            //show base type's size


            void printIt(int a);
            void printIt(double b);
            void printIt(string c);
            void tprint();

            void showSize();
            void testSwitch();
            int sum1(int a,int b=20);
            void randData();
            void tarr();
            void tstr();
            void tPointReferce();
            //时间
            void ttime();
            void tfile();
            //静态类
            void tstaticclass();
            //文件
            void tdealFile();
            void tObj();
            //异常处理
            void tException();
            double division(int a, int b);

            //内存管理
            void tMemmory();
            namespace firstSpace {
                void func1(){
                    std::cout<< "firstSpace func1" <<std::endl;
                }

            }
            namespace thirdSpace{
                namespace fourth{
                    void func2(){
                        std::cout<< "thirdSpace func1" <<std::endl;
                    }
                }
            }

            namespace secondSpace {
                void func1(){
                    std::cout<< "secondSpace func1" <<std::endl;
                }
            }
            void tnamespace();
            using namespace firstSpace;
            using namespace secondSpace;
            using namespace thirdSpace::fourth;

            //use namespace ff1 = secondSpace::;
            //继承构造函数的调用
            void testInherit();

            //测试模板的使用
            void testTmpFunc();

            //信号
            void tsignal();

            //多线程
            void tthread();

            //stl
            void tSTL();


            int main(int argc, const char * argv[]) {
                //cout << tadd(1,120)<<endl;
                //cout << sum1(1)<<" "<< sum1(1,1)<<endl;
                //cout << sqrt(4)<<endl;
                //randData();
                //tarr();
                //tstr();
                //tPointReferce();
                //ttime();
                //tfile();
                //tObj();
                //tprint();
                //tstaticclass();
                //tdealFile();
                //tException();
                //tMemmory();
                //tnamespace();
                //testInherit();
                //testTmpFunc();
                //tsignal();
                //tthread();
                tSTL();
                cout << "end"<<endl;
                return 0;
            }

            //test stl
            void tSTL(){
                //stl的使用
                vector<int> s;
                cout << "s.size:" << s.size()<<endl;
                int i;
                for(i=0;i<10;i++){
                    s.push_back(i);
                }
                cout << "s.size:" << s.size()<<endl;
                for(i=0;i<10;i++){
                    cout << s[i] << ",";
                }
                cout << endl;
                //stl的循环
                s.pop_back();
                s.pop_back();
                vector<int>::iterator it1 = s.begin();
                while(it1 != s.end()){
                    cout << *it1 << " ";
                    it1++;
                }

                cout << endl;
            }


            void * sayhi(void *arg){
                int tid = *((int*)arg);
                cout << tid <<"\n" << endl;
                pthread_exit(NULL);
            }
            //测试线程
            void tthread(){
                pthread_t tids[NUM_THREADS];
                int i;
                for(i=0;i<NUM_THREADS;++i){
                     int ret = pthread_create(&tids[i], NULL, sayhi,(void*)(&(tids[i])));
                    if(ret < 0) cout << "error"<<endl;
                }
                pthread_exit(NULL);
            }

            void signalHandle(int sig){
                cout << "this sig is  "<< sig << endl;
                exit(0);
            }
            //处理信号
            void tsignal(){
                int i = 0;
                signal(SIGINT, signalHandle);
                while(1){
                    cout << "waiting...." << endl;
                    sleep(1);
                    i++;
                    if(i == 3){
                        raise(SIGINT);
                    }
                }

            }

            //测试模板类和模板函数
            void testTmpFunc(){
                cout << "tmp";
                int i = 39;
                int j = 20;
                cout << "Max(i, j): " << Max(i, j) << endl;

                double f1 = 13.5;
                double f2 = 20.7;
                cout << "Max(f1, f2): " << Max(f1, f2) << endl;

                string s1 = "Hello";
                string s2 = "World";
                cout << "Max(s1, s2): " << Max(s1, s2) << endl;

                try {
                    Stack<RangeShape> rs;
                    RangeShape rs1(11,11);
                    rs.push(rs1);
                    cout << (rs.top()).getArea() << endl;
                    rs.pop();
                    rs.top();
                } catch (exception &e) {
                    cout << "try catch exception"<<e.what() <<endl;
                }

            }


            /**
             测试继承的构造器和析构函数
                默认会调用父类的构造器
             **/
            void testInherit(){
                RangeShape rs1(11,11);
                cout << rs1.getArea()<<endl;
            }


            //测试命名空间
            void tnamespace(){
                firstSpace::func1();
                secondSpace::func1();
                thirdSpace::fourth::func2();
            }


            void tMemmory(){
                int ROW = 2;
                int COL = 3;
                double **pvalue  = new double* [ROW]; // 为行分配内存

                // 为列分配内存
                for(int i = 0; i < COL; i++) {
                    pvalue[i] = new double[COL];
                }
                delete [] pvalue;

                Box* myBoxArray = new Box[4];

                delete [] myBoxArray; // Delete array
            }

            struct MyException : public exception
            {
                const char* what() const throw ()
                {
                    return "C++ Exception";
                }
            };

            //异常
            void tException(){
                try {
                    throw MyException();
                } catch (exception& e) {
                    cout <<e.what() <<endl;
                }
                //division(1, 0);
            }

            double division(int a, int b)
            {
                if( b == 0 )
                {
                    throw "Division by zero condition!";
                }
                return (a/b);
            }

            //文件操作
            void tdealFile(){
                fstream fp;

                fp.open("/Users/kang/Documents/CProject/xcode_project/dpool/dpool/t.log",ios::trunc|ios::out);
                fp << "t1" <<endl;
                //fp.seekp(10, ios::cur);
                fp << "t2" << endl;
                //fp.seekp(10, ios::cur);
                fp << "t3" <<endl;
                //fp.seekp(10, ios::cur);
                fp << "t4" << endl;
                fp.close();
                char data[100];
                fp.open("/Users/kang/Documents/CProject/xcode_project/dpool/dpool/t.log",ios::in);
                while(!fp.eof()){
                    //fp.read(data, 100);
                    fp.getline(data, 100);
                    cout << "read:" << data << endl;
                }
                fp.close();
                cout << data <<endl;
            }



            void tstaticclass(){
                //静态对象和全局对象一直存在
                static Box b1(1,1,1);
            }

            //方法重载
            void tprint(){
                printIt(11);
                printIt(11.1);
                printIt("it=11.1");

                Box b1(1,1,1);
                Box b2(2,2,2);
                Box b3;
                b3 = b1 + b2;
                cout << "volume=" << b3.getVolume()<<endl;
                //多态
                RangeShape rs;
                rs.setHeight(1);
                rs.setWeight(2);
                cout << rs.getArea() << endl;

                //虚函数,纯虚函数
                Shape *sp1;
                sp1 = &rs;
                cout << sp1->getArea() << endl;



            }
            void printIt(int a){
                cout << a <<endl;
            }
            void printIt(double b){
                cout << b <<endl;
            }
            void printIt(string c){
                cout << c <<endl;
            }


            inline int maxData(int x,int y){
                return x>y?x:y;
            }

            void tObj(){
                Box b1;
                b1.setHeight(1);
                b1.setBreadth(2);
                b1.setLength(3);
                double volume = b1.getVolume();
                cout << volume << endl;

                char name1[10] = "tom";
                b1.setName(name1);
                cout << b1.getName()<<endl;
                Box b2(3,3,3);
                cout<< b2.getVolume()<<endl;

                //拷贝构造函数
                Box b3(11);
                cout << b3.ptr2 << ":" << *(b3.ptr2)<<endl;
                Box b4 = b3;
                int i = 12;
                b4.ptr2 = &i;
                cout << b4.ptr2 << ":" << *(b4.ptr2)<<endl;
                cout << b3.ptr2 << ":" << *(b3.ptr2)<<endl;
                Box b5(2,3,4);
                cout<< b5.getHeight()<<endl;
                std::cout << &b5 << std::endl;
                printHeight(b5);
                //内联
                cout << maxData(11,2) << endl;
                //指向对象的指针
                Box *pb;
                pb = &b5;
                cout << pb->getHeight() << endl;
                cout << "initCount="<< Box::initCount <<endl;

                //继承
                RangeShape rs;
                rs.setHeight(11);
                rs.setWeight(11);
                cout << rs.getArea() << endl;

            }


            /**
             fstream  // 文件流
             ifstream  // 输入文件流
             ofstream  // 输出文件流
             参考http://www.newxing.com/Tech/Program/Cpp/577.html
             **/
            void tfile(){
                fstream f("/Users/kang/Documents/CProject/xcode_project/dpool/dpool/t.log",ios::out);
                if(!f) {
                    cout << "create faild";
                }else{
                    cout << "create sucess" << endl;
                }
                f << "test" << endl;
                f << "num123" << endl;
                f.close();
                char str[20];
                f.open("/Users/kang/Documents/CProject/xcode_project/dpool/dpool/t.log",ios::in);
                f.getline(str, 20);
                cout << str << endl;
                f.close();
            }

            //ttime
            void ttime(){
                time_t t1 = time(NULL);
                cout << t1 <<endl;

                tm *ltm = localtime(&t1);

                // 输出 tm 结构的各个组成部分
                cout << "Year: "<< 1900 + ltm->tm_year << endl;
                cout << "Month: "<< 1 + ltm->tm_mon<< endl;
                cout << "Day: "<<  ltm->tm_mday << endl;
                cout << "Time: "<< 1 + ltm->tm_hour << ":";
                cout << 1 + ltm->tm_min << ":";
                cout << 1 + ltm->tm_sec << endl;
            }

            void tPointReferce(){
                int *ptr = NULL;
                cout << ptr<<endl;
                int ss = 11;
                int &rss = ss;
                cout <<ss <<" " << rss <<" "<<&rss;
            }

            void tstr(){
                //cstr
                char str1[20] = "sina_id:1671318";
                char str2[40];
                memset(str2, '\0',30);
                //copy add size
                strcpy(str2, str1);
                cout << str2<<" len=" <<strlen(str2)<<endl;
                strcat(str2, str1);
                cout << str2<<" len=" <<strlen(str2)<<endl;

                //cppstr
                string cppstr1 = "info";
                string cppstr2 = "info2";
                string cppstr3;
                cppstr3 = cppstr1;
                cout <<cppstr1 + cppstr2 << cppstr3 <<"cppstr3 size="<< cppstr3.size()<<endl;
            }

            void tarr(){
                int arr[] = {1,2,3,4,5};
                for(int i = 0;i<5;i++){
                    cout << arr[i] <<"\t";
                }
                cout << endl;
            }
            void randData(){
                int i,j;
                // 设置种子
                srand((unsigned)time(NULL));
                /* 生成 10 个随机数 */
                for( i = 0; i < 2; i++ )
                {
                    // 生成实际的随机数
                    j= rand();
                    cout <<"随机数: " << j << endl;
                }
            }

            void showSize(){
                cout << "Size of char : " << sizeof(char) << endl;
                cout << "Size of int : " << sizeof(int) << endl;
                cout << "Size of short int : " << sizeof(short int) << endl;
                cout << "Size of long int : " << sizeof(long int) << endl;
                cout << "Size of float : " << sizeof(float) << endl;
                cout << "Size of double : " << sizeof(double) << endl;
                cout << "Size of wchar_t : " << sizeof(wchar_t) << endl;
            }

            int sum1(int a,int b){
                return a+b;
            }

            void testSwitch(){
                int a = 1;
                switch (a) {
                    case 1:
                        cout << "inner " <<endl;
                        switch (a) {
                            case 1:
                                cout << "inner 1" <<endl;
                                break;

                            default:
                                cout << "in default"<<endl;
                                break;
                        }
                        break;
                    default:
                        cout << "out default" <<endl;
                break;
        }

    }

    //
            //  basic_syntax.h
            //  dpool
            //
            //  Created by bikang on 16/8/22.
            //  Copyright (c) 2016年 bikang. All rights reserved.
            //

            #ifndef __dpool__basic_syntax__
            #define __dpool__basic_syntax__

            #include <stdio.h>
            #include <iostream>
            #include <vector>

            using namespace std;

            template <class T>
            class Stack {
            private:
                vector<T> elems;     // 元素

            public:
                void push(T const&);  // 入栈
                void pop();               // 出栈
                T top() const;            // 返回栈顶元素
                bool empty() const{       // 如果为空则返回真。
                    return elems.empty();
                }
            };

            template <class T>
            void Stack<T>::push (T const& elem)
            {
                // 追加传入元素的副本
                elems.push_back(elem);
            }

            template <class T>
            void Stack<T>::pop ()
            {
                if (elems.empty()) {
                    throw out_of_range("Stack<>::pop(): empty stack");
                }
                // 删除最后一个元素
                elems.pop_back();
            }

            template <class T>
            T Stack<T>::top () const
            {
                if (elems.empty()) {
                    throw out_of_range("Stack<>::top(): stack is empty");
                }
                // 返回最后一个元素的副本
                return elems.back();
            }




            int tadd(int x,int y);

            class Box{

            private:
                char name[50];
            protected:
                double length;
                double breadth;
                double height;
            public:
                static int initCount;
                int *ptr,*ptr2;
                friend void printHeight(Box box);
                void setLength(double len);
                void setBreadth(double bre);
                void setHeight(double hei);
                void setName(char *str);
                double getLength();
                double getHeight();
                double getBreadth();
                char* getName();
                double getVolume(void);
                static int getInitCount();
                Box();
                Box(int count);
                Box(double len,double bre,double hei);
                Box(const Box &obj);
                Box operator+(const Box& b);
                ~Box();
            };

            class Shape{
            public:
                Shape(){
                    std::cout << "shape construct"<<std::endl;
                }
                Shape(int wei,int hei){
                    weight = wei;
                    height = hei;
                }
                ~Shape(){
                    std::cout << "shape destruct"<<std::endl;
                }
                void setWeight(int we){
                    weight = we;
                }
                void setHeight(int he){
                    height = he;
                }
                /*
                virtual int getArea(){
                    std::cout << "shape arrea"<<std::endl;
                    return weight * height;
                }*/
                virtual int getArea() = 0;
            protected:
                int weight;
                int height;
            };

            class PaintCost{
            public:
                PaintCost(){
                    std::cout << "PaintCost construct"<<std::endl;
                }
                ~PaintCost(){
                    std::cout << "PaintCost destruct"<<std::endl;
                }

                int getCost(int cost){
                    return 30*cost;
                }
            };

            class RangeShape:public Shape,public PaintCost{
            public:
                RangeShape(){
                    std::cout << "RangeShape construct"<<std::endl;
                }
                RangeShape(int wei,int hei):Shape(wei,hei){

                }
                ~RangeShape(){
                    std::cout << "RangeShape destruct"<<std::endl;
                }
                int getArea(){
                    std::cout << "RangeShape area"<<std::endl;
                    return 2*weight*height;
                }

            };

            template <typename T>
            inline T const& Max(T const& a ,T const& b){
                return a > b ? a:b;
            }




                #endif /* defined(__dpool__basic_syntax__) */


                //
                //  basic_syntax.cpp
                //  dpool
                //
                //  Created by bikang on 16/8/22.
                //  Copyright (c) 2016年 bikang. All rights reserved.
                //

                #include "basic_syntax.h"
                #include <cstring>
                #include <iostream>

                //初始化静态成员
                int Box::initCount = 0;


                void Box::setLength(double len){
                    length = len;
                }
                void Box::setBreadth(double bre){
                    breadth = bre;
                }
                void Box::setHeight(double hei){
                    height = hei;
                }
                Box::Box(){
                    ptr = new int();
                    std::cout << " init box" <<std::endl;
                    initCount++;
                }

                Box Box::operator+(const Box& b){
                    Box b1;
                    b1.length = b.length + this->length;
                    b1.height = b.height + this->height;
                    b1.breadth = b.breadth + this->breadth;

                    return b1;
                }

                Box::Box(double len,double bre,double hei):length(len),breadth(bre),height(hei)
                {
                    ptr = new int();
                    std::cout << "other init func" <<std::endl;
                    initCount++;
                }

                Box::Box(int count){
                    ptr = new int();
                    *ptr = count;
                    ptr2 = new int();
                    *ptr2 = count;
                    initCount++;
                }
                //拷贝构造函数
                Box::Box(const Box &obj){
                    this->ptr = new int();
                    this->ptr = obj.ptr;

                    this->ptr2 = new int();
                    this->ptr2 = obj.ptr2;
                    this->length = obj.length;
                    this->height = obj.height;
                    this->breadth = obj.breadth;
                    initCount++;
                }
                int Box::getInitCount(){
                    return initCount;
                }

                Box::~Box(){
                    //delete ptr;
                    std::cout << " free box"<<std::endl;
                }
                double Box::getLength(){
                    return this->length;
                }
                double Box::getHeight(){
                    return height;
                }
                double Box::getBreadth(){
                    return breadth;
                }
                double Box::getVolume(void){
                    return length * breadth* height;
                }
                void Box::setName(char *str){
                    strcpy(name, str);
                }
                char* Box::getName(){
                    return name;
                }

                void printHeight(Box box){
                    std::cout << &box << std::endl;
                    std::cout << "getVolume=" << box.getVolume() << std::endl;
                    std::cout << "height=" << box.getHeight() << std::endl;
                    std::cout << "length=" << box.getLength() << std::endl;
                    std::cout << "breadth=" << box.getBreadth() << std::endl;
                }

                int tadd(int x,int y){
                    return x+y;
                }
0
0

查看评论
* 以上用户言论只代表其个人观点,不代表CSDN网站的观点或立场
    个人资料
    • 访问:142131次
    • 积分:3523
    • 等级:
    • 排名:第9548名
    • 原创:214篇
    • 转载:22篇
    • 译文:0篇
    • 评论:10条
    博客专栏