自己看看

#include <Windows.h>    //默认写在最上方
#include <iostream>        //输入输出流
#include <locale.h>        //宽字符 显示的头文件  ,以及函数 setlocale(LC_ALL,"");

#include <vector>        //STL 
#include <list>            //STL 
#include <deque>        //STL 
#include <set>            //STL
#include <map>            //STL
#include <hash_map>        //STL 
#include <functional>    //STL 函数对象
#include <algorithm>    //STL 算法,大概有100多个算法

#include <string.h>        //字符串
#include <cstring>        //字符串
#include <string>        //字符串

#include <bitset>        //二进制头文件

#include <cstddef>        //size_t的头文件

#include <xutility>

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <errno.h>
#include <sysinfoapi.h>





using namespace std;


#define Conn(x,y) x##y
#define ToChar(x) #@x
#define ToString(x) #x


class TestObject
{
public:
    TestObject()
    {
        this->m_iData1 = 10;
        this->m_iData2 = 20;
        this->m_iData3 = 30;
    }

private:
    int m_iData1;
    int m_iData2;
    int m_iData3;
};


enum OpenModes
{
    nInput,
    nOutput,
    nAppend,
    nX = 1,
    nY,
    nZ = 2,
};

typedef struct Student
{
    Student()
    {
        nAge = 0;
        nLen = 0;
    }

    int nAge;
    int nLen;
}Hello;

//前包,后不包..一定要注意 end的迭代器
bool FindInt(vector<int>::iterator begin, vector<int>::iterator end, int &nValue)
{
    bool find = false;

    while (begin != end)
    {
        if (*begin == nValue)
        {
            find = true;
            break;
        }
        else
        {
            begin++;
        }
    }


    if (find)
    {
        return true;
    }
    else
    {
        return false;
    }


}//这个就有点像STL里面的 find()函数

void printt(int elem)
{
    cout << elem << endl;
    cout << "aaaa" << endl;
}


int& add_one(int &x)
{

    ++x;
    return x;

}

int AddThree(int *p)
{
    *p = *p + 10;
    return *p;

}

void printValue_5(int(*x)[10], int rowSize)
{
    for (int i = 0; i != rowSize;i++)
    {

        for (int j = 0; j != 10;++j)
        {
            cout << x[i][j] << " ";
        }
        cout << endl;
    }


}






class CBook
{

public:
    int price;
    int num;
    int sum;

    int GetPrice() const;


};


int CBook::GetPrice() const
{
    int a = 1;
    a = a + 10;    //这个是可以进行写操作的


    //this->num = 2;//const 放在()后面,说明,不允许修改this的数据.不能进行 写 操作


    return 0;
}

CBook obj2;


//递归的实例
void DoA()
{
    //cout << "Hello panzhengming" << endl;
    //DoA();
}

long Factorial(int n)//阶乘
{
    //数学定义0的阶乘是 1.这是基准

    if ( 0 == n)
    {
        return 1;
    }
    else
    {
        return n * Factorial(n - 1);
    }
}


int main(int argc,char **argv)
{
    setlocale(LC_ALL, "");

    /*
    CBook obj;
    obj.GetPrice();
    cout << obj.sum << endl;//局部对象,未初始化的变量都是垃圾就数据
    cout << obj2.sum << endl;//全局对象,未初始化的变量都是默认值
    */



    /*这段代码,我只是想演示 vector的长度是正常的计数,不是-1
    vector<int> a;
    a.push_back(1);
    a.push_back(2);
    int nSize = a.size();
    cout << nSize << endl;
    */



    /*
    vector<int> vec1;
    vec1.clear();
    vec1.push_back(10);
    vec1.push_back(20);
    vec1.push_back(30);
    vec1.push_back(40);
    vec1.push_back(50);
    //vec1数据
    for (size_t i = 0; i < vec1.size();i++)
    {
        cout << vec1[i] << endl;
    }

    cout << "------------------" << endl;
    //vec2数据
    vector<int> vec2(vec1);//用vec1初始化vec2
    for (size_t i = 0; i < vec2.size(); i++)
    {
        cout << vec2[i] << endl;
    }

    cout << "--------------------------" << endl;
    vector<int> vec3(20,5);//20个数据,每个元素的值都是5
    for (size_t i = 0; i < vec3.size(); i++)
    {
        cout << vec3[i] << endl;
    }


    //vector<Foo> a;
    //vector<Foo> b(10, 1);//10表示vector数量,1表示Foo构造函数的参数


    vector<int>::iterator first = vec1.begin();
    vector<int>::iterator last = vec1.end();
    if (first != last)
    {
        int number = *first + *(first + 1);
        cout << number << endl;

        first++;
    }
    
    */


    /*
    vector<int>    vec1;
    vec1.push_back(10);
    vec1.push_back(20);
    vec1.push_back(30);
    vec1.push_back(40);
    vec1.push_back(50);

    const vector<int>    vec2(vec1);

    //常迭代器
    vector<int>::iterator Iter = vec2.begin();

    while (Iter != vec2.end())
    {
        //修改元素值
        //*Iter = *Iter + 10000;

        cout << *Iter << endl;

        Iter++;
    }

    */

    /*
    vector<string>    list1;
    list1.push_back("Beijing");
    list1.push_back("shanghai");
    list1.push_back("nnajing");
    list1.push_back("yancheng");
    list1.push_back("xiangshui");


    list1.resize(3);
    for (vector<string>::iterator Iter = list1.begin(); Iter != list1.end();Iter++)
    {
        cout << *Iter << endl;
    }

    //vector<string>::iterator Iter = list1.begin(); 
    //while (Iter != list1.end())
    //{
    //    cout << *Iter << endl;
    //    Iter++;
    //}



    //vector<int>::size_type count = list1.size();
    //vector<int>::size_type maxCount = list1.max_size();

    //cout << count << "   " << maxCount << endl;

    //if (list1.empty())
    //{
    //    cout << "容器是空的" << endl;
    //}
    //else
    //{
    //    cout << "容器不是空的" << endl;
    //}
    //cout << list1.capacity() << endl;
    //cout << list1.size() << endl;
    
    //cout << list1.size() << endl;
    //cout << list1.capacity() << endl;

    //list1.resize(0);
    //if (list1.empty())
    //{
    //    cout << "empty()" << endl;
    //}
    */


/*
    vector<int>    list1;

    list1.push_back(11);
    list1.push_back(22);
    list1.push_back(33);
    list1.push_back(44);

    int a = list1.at(3);
    cout << a << endl;
    */


/*
    list<string> ilist;
    ilist.push_back("apple");
    ilist.push_back("bill");
    ilist.push_back("cat");
    ilist.push_back("dog");
    ilist.push_back("egg");
    ilist.push_back("fish");
    ilist.push_back("girl");


    //ilist.pop_front();
    //ilist.pop_back();


    //string sValue("bill");
    //string svalue2 = "girl";
    //list<string>::iterator Iter1 = find(ilist.begin(), ilist.end(), sValue);
    //list<string>::iterator Iter2 = find(ilist.begin(), ilist.end(), svalue2);

    //if (Iter1 != ilist.end() && Iter2 != ilist.end())
    //{
    //    cout << "找到了 " << sValue << endl;
    //    ilist.erase(Iter1, Iter2);
    //}
    //else
    //{
    //    cout << "没找到 " << sValue << endl;
    //}

    ilist.erase(ilist.begin(), ilist.end());
    if (ilist.empty())
    {
        cout << "全部删除了,之所以能删除是因为 ilist.end()表示最后1个后1个, 所以前面是全部删除了" << endl;
    }
    else
    {
        cout << "no" << endl;
    }

    for (list<string>::iterator Iter = ilist.begin(); Iter != ilist.end();Iter++)
    {
        cout << *Iter << endl;
    }


    */




    /*
    vector<int> a;
    vector<int> b;
    vector<int> c;

    a.push_back(1000);
    a.push_back(2000);
    a.push_back(3000);
    a.push_back(4000);

    b.push_back(11);
    b.push_back(22);
    b.push_back(33);

    c.push_back(66);
    c.push_back(77);
    c.push_back(88);

    cout << "a---------" << endl;
    for (vector<int>::iterator Itera = a.begin(); Itera != a.end();Itera++)
    {
        cout << *Itera << endl;
    }

    cout << "b----" << endl;
    for (vector<int>::iterator Iterb = b.begin(); Iterb != b.end();Iterb++)
    {
        cout << *Iterb << endl;
    }
    

    cout << "------------------------------------------------开始交换" << endl;

    //a.swap(b);
    b.swap(a);

    cout << "a---------" << endl;
    for (vector<int>::iterator Itera2 = a.begin(); Itera2 != a.end(); Itera2++)
    {
        cout << *Itera2 << endl;
    }

    cout << "b----" << endl;
    for (vector<int>::iterator Iterb2 = b.begin(); Iterb2 != b.end(); Iterb2++)
    {
        cout << *Iterb2 << endl;
    }

    cout << "赋值 -------------------------------------------------------------" << endl;

    a = b;

    for (vector<int>::iterator Itera2 = a.begin(); Itera2 != a.end(); Itera2++)
    {
        cout << *Itera2 << endl;
    }

    cout << "b----" << endl;
    for (vector<int>::iterator Iterb2 = b.begin(); Iterb2 != b.end(); Iterb2++)
    {
        cout << *Iterb2 << endl;
    }

    cout << "赋值 -------------------------------------------------------------" << endl;

    a.assign(c.begin(), c.end());
    for (vector<int>::iterator Itera2 = a.begin(); Itera2 != a.end(); Itera2++)
    {
        cout << *Itera2 << endl;
    }

    cout << "赋值 -------------------------------------------------------------" << endl;


    a.assign(5, 8888);
    for (vector<int>::iterator Itera2 = a.begin(); Itera2 != a.end(); Itera2++)
    {
        cout << *Itera2 << endl;
    }


    cout << "----------------------------------------------容量 增长" << endl;
    a.reserve(5);
    cout << a.size() << "  " << a.capacity() << endl;
    */



/*
    cout <<"----------------------------------------------------------------deque类"<<endl;


    deque<int> a;
    a.push_back(3);
    a.push_back(4);

    a.push_front(2);
    a.push_front(1);

    for (deque<int>::iterator Iter = a.begin(); Iter != a.end();Iter++)
    {
        cout << *Iter << endl;
    }


    cout << "删除" << endl;

    a.pop_back();
    for (size_t nCount = 0; nCount < a.size();nCount++)
    {
        cout << a[nCount] << endl;
    }

    */


/*

    list<int> a;
    a.push_front(3);
    a.push_front(2);
    a.push_back(4);
    a.push_front(1);
    a.push_front(0);

    for (list<int>::iterator Iter = a.begin(); Iter != a.end();Iter++)
    {
    cout << *Iter << " ";
    }

    cout << endl;
    a.reverse();
    for (list<int>::iterator Iter = a.begin(); Iter != a.end(); Iter++)
    {
    cout << *Iter << " " ;
    }

*/




    //算法
/*
    //自动排序的红黑树
    //set<int> a;                //less<int>是默认的函数对象
    set<int, less<int>> a;    //less<int>是默认的函数对象
    //set<int, greater<int>> a;

    a.insert(9);
    a.insert(3);
    a.insert(8);
    a.insert(1);
    a.insert(5);
    a.insert(11);

    set<int,less<int>>::iterator Iter = a.begin();



    while (Iter != a.end())
    {
        cout << *Iter << endl;
        Iter++;
    }

    //for_each(a.begin(), a.end(), 函数对象);
    cout << "-------------------" << endl;
    for_each(a.begin(), a.end(), printt);*/



//     vector<int> ivec;
//     for (int i = 1; i <= 9;i++)
//     {
//         ivec.push_back(i);
//     }
// 
//     ivec.push_back(4);
//     ivec.push_back(4);
//     ivec.push_back(4);
//     ivec.push_back(4);
// 
// 
// 
//     int num = count(ivec.begin(), ivec.end(), 4);
//     cout << num << "个4" << endl;
//     cout << "-----------" << endl;
// 
//     vector<string> temp;
//     temp.push_back("aaaaa");
//     temp.push_back("aaaaa");
//     temp.push_back("bbbbb");
//     temp.push_back("ccccc");
// 
//     num = count(temp.begin(), temp.end(), "aaaaa");
//     cout << num << "个 aaaaa" << endl;



    //min or max
//     vector<int> temp;
//     temp.clear();
//     for (int i = -10; i <= 10; i++)
//         temp.push_back(i);
// 
// 
//     vector<int>::iterator Iter = temp.begin();
//     //while (Iter != temp.end() )
//     //{
//     //    cout << *Iter << endl;
//     //    Iter++;
//     //}
// 
//     cout << *max_element(temp.begin(), temp.end()) << endl;



/*
    list<int> ilist;
    for (int i = 0; i < 10;i++)
    {
        ilist.insert(ilist.end(), i);
    }
    for (int i = 0; i < 10; i++)
    {
        ilist.insert(ilist.end(), i);
    }

    list<int>::iterator Iter = ilist.begin();
    
    list<int>::iterator IterPos;
    IterPos = find(ilist.begin(), ilist.end(), 4);
*/


/*
    string s("asdfaslasdfkljhlkj");
    string::size_type pos = s.find("asd");
    if (pos != string::npos)
    {
        cout << "找到了" << endl;
        cout << pos << endl;
    }
    else
    {
        cout << "没找到" << endl;
    }
*/




    





/*
    deque<int> idep;
    for (int i = 1; i < 10;i++)
    {
        idep.push_back(i);
    }


    deque<int>::iterator Iter = idep.begin();

    search()*/





    //交换算法

/*
    vector<int> ivec;
    deque<int> ideq;
    ivec.clear();
    ideq.clear();
    for (int i = 0; i <= 9;i++)
    {
        ivec.push_back(i);
    }
    for (int i = 11; i <= 15; i++)
    {
        ideq.push_back(i);
    }
    



    swap_ranges(ivec.begin(), ivec.end(), ideq.begin());



    for (vector<int>::iterator Iter = ivec.begin(); Iter != ivec.end(); Iter++)
    {
        cout << *Iter << endl;
    }
    cout << "-------------------------" << endl;
    for (deque<int>::iterator Iter = ideq.begin(); Iter != ideq.end(); Iter++)
    {
        cout << *Iter << endl;
    }*/
    

    
/*
    vector<int> ivec1;
    vector<int> ivec2;

    for (int i = 0; i <= 9; i++)
    {
        ivec1.push_back(i);
    }
    for (int i = 11; i <= 30; i++)
    {
        ivec2.push_back(i);
    }


    ivec1.swap(ivec2);
    

    for (vector<int>::iterator Iter = ivec1.begin(); Iter != ivec1.end(); Iter++)
    {
        cout << *Iter << endl;
    }
    cout << "-------------------------" << endl;
    for (vector<int>::iterator Iter = ivec2.begin(); Iter != ivec2.end(); Iter++)
    {
        cout << *Iter << endl;
    }*/

    
/*
    list<string> slist;
    slist.push_back("hello");
    slist.push_back("hi");
    slist.push_back("good morning");

    
    replace(slist.begin(), slist.end(), "hello", "Doris");
    for (list<string>::iterator Iter = slist.begin(); Iter != slist.end();Iter++)
    {
        cout << *Iter << endl;
    }
*/


    
/*
    int source[] = { 1, 2, 2, 3, 12, 3, 1343665, 78, 875, 4, 5, 34, 5, 87, 4, 67341 };
    int Num = sizeof(source) / sizeof(source[0]);
    cout << Num << endl;


    list<int> ilist;
    copy(source, source + Num, back_inserter(ilist));

    list<int>::iterator Iter = ilist.begin();
    while (Iter != ilist.end())
    {
        cout << *Iter << "  ";
        Iter++;
    }
    cout << endl;
    unique(ilist.begin(), ilist.end());
    for (list<int>::iterator Iter = ilist.begin(); Iter != ilist.end();Iter++)
    {
        cout << *Iter << "  ";
    }
*/




/*
    string name("AnnaBella");
    string::size_type pos1 = name.find("nn");

    if (string::npos == pos1)
        cout << "没找到,返回特定的code,            string::npos" << endl;
    else
        cout << "找到了,下标是" << pos1 << endl;*/


/*

    string name = "r2d3";
    string numerics("tew9993");
    string::size_type pos = name.find_first_of(numerics);
    if (string::npos == pos)
    {
        cout << "not find" << endl;
    }
    else
    {
        cout << "find " << endl;
    }*/


/*
    string str = "C++ Primer 3rd ed";
    str.replace(11, 3, "4Fourth");
    cout << str << endl;*/
    




/*
    int arr[] = { 9, 1, 23, 4 ,8};    
    int *p = arr;

    cout << *arr << endl;        //数组名就是指针
    cout << *p << endl;

    p = arr;
    cout << *p << endl;
    p = arr + 4;                //指针or数组名 移动    
    cout << *p << endl;

    p = p + 11;                    //越界
    cout << *p << endl;


    int *p1 = arr;        
    int *p2 = arr + 4;
    ptrdiff_t n = p1 - p2;        //ptrdiff_t 类型专门用于计算 2个指针之间的距离...只对指针有效,对数组名无效
    cout << n << endl;



    cout << "开始循环:" << endl;
    const size_t arr_sz = 5;                    
    int int_arr[arr_sz] = { 0, 1, 2, 3, 4 };    //长度是常量,所有会定义const arr_sz

    //逗号表达式,最后1个值是固定的,类似迭代器的写法了,这里的pend相当于是数组的尾后地址..C++允许的...需要好好理解会
    for (int *pBegin = int_arr, *pend = int_arr + arr_sz; pBegin != pend;++pBegin)    
    {
        cout << *pBegin << endl;
    }*/




    
/*
    int arr[] = { 9, 1, 23, 4, 8 };
    int *p = arr;


    cout << arr << endl;
    cout << p << endl;

    p = arr + 3;
    cout << p << "  " << *p << "  " << &(arr[3]) << endl;    //的确是的:指针移动了,P就指向了新的地址*/



/*
    double temp = 1.2;
    double *p = &temp;


    const double temp2 = 2.3;
    //p = &temp2;                //普通指针不能指向常量指针
    const double *p2;
    p2 = &temp2;                //常指针指向常对象 

    p2 = &temp;                    //常对象可以指向普通对象*/



/*
    string s("hello");                            //可以修改,C++风格字符串            没有

    char ca3[] = "hello";                        //可以修改,C风格字符串            有隐含的
    char ca2[] = { 'C', '+', '+', NULL };        //这也是C风格字符串                 = NULL 2者等价

    char ca1[] = { 'C', '+', '+' };                //这是字符数组,不是字符串,因为没有


    char *cp2 = "panzhengming";        //指向字符串的指针

    int n = 0;
    while (*cp2)
    {
        n++;
        cp2++;

        if (n == 3)
        {
            cout << *cp2 << " ";
            break;
        }

        
    }

    false;

    cout << strlen(cp2) << endl;*/





/*
    vector<vector<int>> temp;
    temp.clear();

    vector<int> a;
    a.clear();
    for (int i = 0; i < 10;i++)
    {
        a.push_back(i);
    }
    temp.push_back(a);


    vector<vector<int>>::iterator Iter = temp.begin();
    while (Iter != temp.end())
    {
        cout << *Iter << endl;
    }*/





/*
    //命令行参数
    cout << "一共" << argc << "个参数" << endl;

    cout << argv[0] << endl;
    cout << argv[1] << endl;
    cout << argv[2] << endl;
    cout << argv[3] << endl;
    
    //但是一定要注意 argv的越界,空字符串的 特殊情况
    */





/*
    这个列子很有意思,2次引用
    int a = 1;
    int &b = add_one(a);
    b++;
    cout << a << " " << b << endl;*/
    



    //hash_map


/*
    注意这样取值是容易错误的 


    map<int, int> temp;
    temp.clear();
    int str = temp[2];
    cout << str << endl;
*/




/*这个有点吊了,新标准的C++支持unicode和编译器设置 就可以使用 中文变量了

unsigned char 潘正明;
潘正明 = 123;
cout << int(潘正明) << endl;

*/



/*
    位元算 
    unsigned int bits = 02;
    cout << bits << endl;

    bits = ~bits;
    cout << bits << endl;
*/


/*
    unsigned char b1 = 0145;
    unsigned char b2 = 0257;
    unsigned char result = b1 | b2;
    cout << (int)result << endl;*/


    /*bitset<32> temp;
    int nSize = temp.size();
    for (int i = 0; i < nSize;i = i + 2)
    {
        temp.set(i);
    }
*/


/*
    bitset<3> bs(7);//用 7的二进制填充bs对象
    cout << bs[0] << " " << bs[1] << " " << bs[2] << endl;
    //cout << bs[3] << endl;//运行时异常


    string strVal = "011";
    bitset<3> bs1(strVal);//记住 string是反向填充 bitset对象
    cout << bs1[0] << " " << bs1[1] << " " << bs1[2] << endl;
    cout << bs1 << endl;//也可以直接输出bitset对象*/


/*
    二进制

    cout << "-------------------------------------------->开始执行程序啦" << endl;
    int *p = new int(111);
    delete p;
    p = 0;
    cout << p << endl;
*/

/*
    sizeof操作

    int nLen = 11;
    cout << sizeof(nLen) << endl;
    cout << sizeof(int) << endl;

    int x[] = { 2, 4, 6, 8, 10, 1, 3, 5, 7, 9 };

    for (int i = 0;i<sizeof(x)/sizeof(int);i++)
    {
        cout << x[i] << "    ";
    }

    cout <<endl << "自定义数据类型Student的存储结构大小: " << sizeof(Student) << endl;*/


    /*逗号表达式
    int x[] = { 2, 4, 6, 8, 10, 1, 3, 5, 7, 9 };
    for (int k = 0, cnt = 10; k < 10;++k,--cnt)
    {
        x[k] = cnt;
    }

    //类似
    int cnt = 10;
    for (int k = 0; k < 10;++k)
    {
        x[k] = cnt;
        cnt--;
    }*/

/*

    //枚举可以直接打印
    cout << nAppend << endl;
    cout << nY << endl;
    cout << nZ << endl;
*/

/*
指针属于非引用参数
int a = 10;
AddThree(&a);
*/
    

    /*
二维数组
    int m[][10] =
    {
        { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 },
        { 2, 3, 4, 5, 6, 7, 8, 9, 10, 11 },
        { 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 }
    };
    
    printValue_5(m, 3);
    */


/*递归    ,普通的循环就是迭代,遍历的意思
//DoA();
int nRet = Factorial(5);
cout << nRet << endl;
for (int i = 0; i <= 10;i++)
{
    cout << i<<"!    = "<<Factorial(i) << endl;
}
*/



/*
    cout << "****************" << endl;
    cout << ::atoi("") << endl;//给""字符串,那么返回的是0
*/




/*STL与指针
    vector<string*> spvec;
    string str;
    cout << "Enter some strings (Ctrl+Z to end)" << endl;
    while (cin >> str)
    {
        string *pstr = new string;
        *pstr = str;
        spvec.push_back(pstr);
    }

    cout << "现在开始输出:" << endl;
    vector<string*>::iterator Iter = spvec.begin();
    while (Iter != spvec.end())
    {
        cout << *Iter << "    " << **Iter << endl;

        ++Iter;
    }


    //内存管理,释放内存
    Iter = spvec.begin();//当前的Iter不是第一次声明的那个Iter .移动过了,所以要重新获取
    while (Iter != spvec.end())
    {
        delete *Iter;
        Iter++;
    }

    */
    










//以下是WindowsAPI编程


    //这个很有趣,哈哈哈
    //MessageBox(NULL, TEXT("panzhengming"), TEXT("命令行直接调用WindowsAPI"), MB_OK);
/*
LPSTR szString = "windows data type ,string";
CHAR lpString[120];
CopyMemory(lpString, szString, lstrlen(szString) + 1);
MessageBox(NULL, lpString, "aaa", MB_OK);
*/

/*读取文件
HANDLE hFileRead;
hFileRead = CreateFile(L"1.cpp", GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hFileRead == INVALID_HANDLE_VALUE)
{
    printf("Can not open file ..error: %x
",GetLastError());
    system("pause");
    return -1;
}

const int buf_size = 256;
CHAR buffer[buf_size];
DWORD nIn;
while (ReadFile(hFileRead, buffer, buf_size, &nIn, NULL) && nIn > 0)
{
    printf("%s
", buffer);
}

*/



/*
//读取文件属性
WIN32_FILE_ATTRIBUTE_DATA wData;
if (!GetFileAttributesEx(L"1.cpp", GetFileExInfoStandard, &wData))
{
    system("pause");
    return -1;
}

PFILETIME lptime = &wData.ftCreationTime;
FILETIME ftLocal;
SYSTEMTIME st;
FileTimeToLocalFileTime(lptime, &ftLocal);
FileTimeToSystemTime(&ftLocal, &st);
printf("%d年%d月%d日, %d时%d分%d秒", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);
//cout << wData.ftCreationTime << "   " << wData.ftLastAccessTime << "   " << wData.ftLastWriteTime << endl;
printf("
%d",wData.ftCreationTime);
*/


/*
//获取文件目录
TCHAR szSystemDir[MAX_PATH];    //MAX_PATH windows定义目录长度最多260
GetSystemDirectory(szSystemDir, MAX_PATH);
printf("%s", szSystemDir);//--获取windows的系统安装目录,因为有人可能装在别的盘符里
*/


/*
//宽字节
char只能存储 ASIC英文字符,不能保存中文字符,也就可以保存其他国家的字符
    使用printf()输出
wchar_t c2 = L'中';        L不能省略,表示宽字符,新编的C语言有wchar_t类型
    使用wprintf(L"%c",c2)输出
    ---------------------------------------



setlocale(LC_ALL, "");//使用宽字符输出的时候,要设置本地化设置,头文件是 #include <locale.h>
wchar_t c2 = L'中';
wprintf(L"%c", c2);//好像是2个字符算1个

*/



/*
ansi 和 unicode 相互转化

setlocale(LC_ALL, "");//本地区域,这样就可以使用 unicode
DWORD dwNum;
char sText[] = "ANSI多字节字符串 转 宽字符串";
dwNum = MultiByteToWideChar(CP_ACP, 0, sText, -1, NULL, 0);//先计算需要多大的存储空间
wchar_t *pwText;
pwText = new wchar_t[dwNum];
if (!pwText)
{
    delete[] pwText;
    return 1;
}
MultiByteToWideChar(CP_ACP, 0, sText, -1, NULL, dwNum);
wprintf(L"m->w:%s", pwText);
MessageBoxW(NULL, pwText, L"Text", MB_OK);
delete[] pwText;


wchar_t wText[] = L"宽字符串 转 多字节字符串";
dwNum = WideCharToMultiByte(CP_OEMCP, 0, wText, -1, NULL, 0, NULL, NULL);
char *psText;
psText = new char[dwNum];
if (!psText)
{
    delete[] psText;
    return 2;
}
WideCharToMultiByte(CP_OEMCP, 0, wText, -1, psText, dwNum, NULL, NULL);
printf("
w->m  %s", psText);
MessageBoxA(NULL, psText, "Text", MB_OK);
*/



/*

    遍历逻辑卷,方法1   逻辑卷名

const int bufsize = 1024;
wchar_t szLogicalDriverStrings[bufsize];
ZeroMemory(szLogicalDriverStrings, bufsize);

GetLogicalDriveStrings(bufsize - 1, szLogicalDriverStrings);
//printf("%s 
", szLogicalDriverStrings);//这个是不能正常打印szLogicalDriverStrings  ,因为szLogicalDriverStrings的字符格式里面包含 ,所以printf()只能显示第一个盘符
PCHAR szDrive;
szDrive = (PCHAR)szLogicalDriverStrings;
do 
{
    printf("%s
", szDrive);
    szDrive = szDrive + 4; //这个地方是我手动写的,我转化不了下面的字符类型
    //szDrive = szDrive + (lstrlen(szDrive) + 1);
} while (*szDrive != '');
*/


/*

遍历逻辑卷,方法2 设备名


const int  buf_size = 1024;
TCHAR buf[buf_size];
HANDLE hVol;
bool bFlag;

hVol = FindFirstVolume(buf, buf_size);
if (hVol == INVALID_HANDLE_VALUE)
{
    printf("no found volumes !
");
    return 1;
}

printf("%s 
",buf);

*/


/*
驱动器属性
GetDriveType();
GetVolumeInformation();

这2个API没写代码,很简单,不会就百度下.感觉很好理解这个
*/

/*
磁盘容量
    磁盘->簇->扇区->字节



DWORD dwTotalClusters;
DWORD dwFreeClusters;

DWORD dwSectPerCulust;
DWORD dwBytesPerSect;

//需要传入盘符号
BOOL ret = GetDiskFreeSpace(TEXT("c:"), &dwSectPerCulust, &dwBytesPerSect, &dwFreeClusters, &dwTotalClusters);
if (!ret)
{
    printf("11111111");
}
printf(" 使用GetDiskFreeSpace()uhoqu磁盘空间信息:
");
printf("总的簇数量:						%d
", dwTotalClusters);
printf("空闲的簇数量:						%d
", dwFreeClusters);
printf("每个簇的扇区数量是:					%d
", dwSectPerCulust);
printf("每个扇区字节数是:					%d
", dwBytesPerSect);
 
 //GetDiskFreeSpaceEx(); ke
*/



/*
    文件操作的4种方式
    1.C
    2.C++
    3.API
    4.MFC
*/


/*

    文件的 删除,移动/重命名,拷贝


DeleteFile();
MoveFile();
CopyFile()
*/


/*

    文件内容拷贝
    //c
    fopen()
    fread()
    fwrite()
    fclose()


    //windows
    CreateFile()
    ReadFile()
    WriteFile()
    CopyFile()

*/



/*
目录与模块



CreateDirectory()
GetCurrentDirectory()
SetCurrentDirectory()
GetModuleFileName()


LoadLibrary()
*/



/*
遍历目录
FindFirstFile()
FindNextFile()
WIN32_FIND_DATA

HANDLE
*/


/*
文件属性和时间
FileTimeToLocalFileTime()//文件时间转化成本地时间
FileTimeToSystemTime()//本地时间转化成系统时间
GetFileAttributesEx()
//低位,高位,位元算


GetFileAttributes()
SetFileAttributes()

*/



/*

内存映射文件

HANDEL hFile
CreateFile()
CreateFileMapping()
MapViewOfFile()


*/





/*

系统信息1

OSVERSIONINFO ovex;
TCHAR szVersionInfo[1024];
*szVersionInfo = NULL;
ovex.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
if (!GetVersionEx(&ovex))    //为啥这个函数编译不过去
{
    printf("error ");
    return 1;
}


*/


/*
系统信息2
    吗的,显示的不完全呀




TCHAR szDirName[MAX_PATH];
GetSystemDirectory(szDirName,MAX_PATH);
printf("系统目录:	 %s
", szDirName);            //好像不同的版本,目录路径 不一样

GetWindowsDirectory(szDirName, MAX_PATH);
printf("windows目录:	 %s
", szDirName);        //window目录

DWORD dwComputerNameLen = MAX_COMPUTERNAME_LENGTH + 1;
GetComputerName(szDirName, &dwComputerNameLen);    //计算机名
printf("计算机名:	 %s
", szDirName);

GetUserName(szDirName, &dwComputerNameLen);        //用户名
printf("用户名:	 %s
", szDirName);

    
BOOL fret;
int aMouseInfo[3];
fret = SystemParametersInfo(SPI_GETMOUSE, 0, &aMouseInfo, 0);// spi是外设的意思
if (fret)
{
    aMouseInfo[2] = 4 * aMouseInfo[2];//设置鼠标移动速度
    SystemParametersInfo(SPI_GETMOUSE, 0, aMouseInfo, SPIF_SENDCHANGE);
}

printf("ok
");

*/





/*
时间


//获取时间
SYSTEMTIME st;
GetLocalTime(&st);//本地时间
printf("Now:%d-%d-%d, %d:%d:%d
", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);


//修改时间,通过结构体字段来实现
st.wHour = 11;
SetLocalTime(&st);
printf("Now:%d-%d-%d, %d:%d:%d
", st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond);


//开机到现在的持续时间                单位是毫秒
DWORD c1 = GetTickCount();            //这个保存的时间太短,类型决定的
ULONGLONG c2 = GetTickCount64();    //常用的是这个,  高版本的windows会有这个函数
printf("%d    %d", c1, c2);


//随机数
const int total = 10000;
int nums[total];
srand(GetTickCount64());            //设置随机种子..还是不太了解

for (int i = 0; i < total;i++)
{
    nums[i] = rand() % 1000;
    printf("%d
", nums[i]);
}


//快速排序
//qsort(nums, total, sizeof(nums[0]), func_cmp); 这个没写,暂时不想写
int nStartTime = GetTickCount();
int nEndTime = GetTickCount();

*/


/*
注册表  读写

//读
HKEY hKey;
TCHAR tchData[64];
long lRet = RegOpenKey(HKEY_LOCAL_MACHINE, _T("hardware\description\system\centralprocessor\0"), &hKey);
if (ERROR_SEVERITY_SUCCESS == lRet)//成功
{
    DWORD dwSize = sizeof(tchData);
    lRet = RegQueryValueEx(hKey, _T("ProcessorNameString"), NULL, NULL, (LPBYTE)tchData, &dwSize);

    if (ERROR_SEVERITY_SUCCESS == lRet)
    {
        printf("%s
", tchData);
    }
}

RegCloseKey(hKey);    //代码是这样的,但是编译不通过


//写

HKEY hKey;
RegCreateKey(HKEY_LOCAL_MACHINE,_T("xxxx\xxx\xxx"),&hKey);
RegSetValue(hKey, NULL, REG_SZ, _T("Liebao"), 6);                                            //这个API只能添加默认的
DWORD dwAge = 30;
RegSetValueEx(hKey, _T("新增的用RegSetValueEx()"), 0, REG_DWORD, (CONST BYTE*)&dwAge, 4);    //这个可以新增新的key
RegCloseKey(hKey);

*/




/*
内存信息


MEMORYSTATUSEX memstatsex;
memstatsex.dwLength = sizeof(memstatsex);

GlobalMemoryStatusEx(&memstatsex);
printf("全部物理内存: %I64u 字节
", memstatsex.ullTotalPhys);
printf("可用物理内存: %I64u 字节
", memstatsex.ullAvailPhys);
printf("全部虚拟内存: %I64u 字节
", memstatsex.ullTotalVirtual);
printf("可用虚拟内存: %I64u 字节
", memstatsex.ullAvailVirtual);
printf("全部页面文件: %I64u 字节
", memstatsex.ullTotalPageFile);
printf("可用页面文件: %I64u 字节
", memstatsex.ullAvailPageFile);


*/

/*
系统信息
SYSTEM_INFO sinf;
GetSystemInfo(&sinf);
*/





/*

堆内存


SYSTEM_INFO si;
HANDLE hHeap1, hHeap2;
DWORD dwHeapNum;

GetSystemInfo(&si);
hHeap1 = HeapCreate(HEAP_NO_SERIALIZE, si.dwPageSize * 2, si.dwPageSize * 10);//堆的页面最小,最大设置
if (hHeap1 == NULL)
{
    printf("创建堆失败
");
    return 1;
}
printf("创建堆成功,初识页面2页,最大是10页
");


hHeap2 = HeapCreate(HEAP_NO_SERIALIZE, 0, 0);//如果不写明的,初始的大小向上取值,最大不限制
printf("创建堆成功,初识页面1页,最大不限制
");

dwHeapNum = GetProcessHeaps(0, NULL);
if (0 == dwHeapNum)
{
    printf("进程至少有个默认堆");
    return 1;
}
cout << dwHeapNum << endl;



PVOID lpMem1, lpMem2;
lpMem1 = HeapAlloc(hHeap1, HEAP_ZERO_MEMORY, si.dwPageSize * 3);
if (lpMem1 == NULL)
{
    printf("error");
    return 1;
}

printf("在堆上分配内存成功,起始地址: 0x%x
", lpMem1);


*/




/*
内存的常用操作
*/







//算法
/*

冒泡


{

    const int nSize = 10;
    //int list[nSize] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
    int list[nSize] = { 11, 33, 55, 77, 999, 222, 44, 66, 88, 10 };


    int a = sizeof(list)/sizeof(int);


    cout << "原始数据:    ";
    for (int i = 0; i < nSize; i++)
    {
        cout << list[i] << "  ";
    }
    cout << endl;
    cout << endl;

    //外层循环是趟数
    for (int n = 0; n < nSize;n++)
    {
        cout << "第" << n + 1 << "趟:    ";

        //内层循环比较大小
        for (int i = 0; i < nSize - 1;i++)
        {
            if (list[i] > list[i+1])
            {
                swap(list[i], list[i + 1]);
            }
        }

        for (int i = 0; i < nSize; i++)
        {
            cout << list[i] << "  ";
        }

        cout << endl;
        
    }
    cout << "-----------------------" << endl;
    for (int i = 0; i < nSize;i++)
    {
        cout << list[i] << "  ";
    }


}


*/





/*
    #define 的用法,3个特殊的符号  
        # 
        ## 
        #@
*/



//用指针访问对象的成员
TestObject *p = new TestObject;
cout << sizeof(p) << endl;



































































































































































    cout << endl;
    system("pause");
    return 0;
}