C/C++中一些基础整理

(1):  函数返回值的问题，就是子函数定义在栈区间和堆区间的问题，详细看浏览器收藏的函数返回值，我觉得子函数返回的字符最好加上static,或从堆上申请空间，这样不会出现函数结束内存释放的问题。还有最重要的一点，
                       *p=NULL;
                       for (int i = 0; i < 100; i++)
	               {
		           *(s+i) = 'w';
	               }
切记这个只是在栈上申请了指针空间，必须还要去堆上申请装数的空间。
     当函数结束时，释放的是你的指针，常量不会释放，所以有时候常量会在一个函数释放之后存在。
(2):
int (*p)[4]: ()优先级高　*p　首先是一个指针，类型是ｉｎｔ，后面的 [4]表明这是一个指向一维整型数组的指针。
int　*p[4]: 　[]优先级高，　p[4] 首先是一个数组，类型是 int *　，也就是这是一个存放４个整型指针的数组ｐ。
(3):sizeof()对数组求长度，是求它在内存中的长度。strlen()求得是实际所占的长度。a[41]="1234567";sizeof(a)=41;strlen(a)=7
sizeof(a) 是指a的内存空间大小，strlen() 查找到“\0”就结束。
(4)用strncpy截取字符串长度，strncpy(a,b+4,7);可以将这里的a,b看成指针。将b的指针向前移动4，就是截取4位以后的位数。
(5)vector<vector<int>> test在vector中表示数组。vector<int> num1(s1.length(),0);指定num1的长度并且全部置为0;
(6)栈的函数 stack<int> s;	s.push(1);  // void push(T t);压栈存入数据	s.push(2);	s.push(3);	
                                int result = s.top(); // T top();只输出第一个顶部数据，不弹栈	
                                s.pop(); // void pop();弹栈存入数据
                                s.empty();//栈为空为真;
(7)队列的函数  queue<int>s;
1. push() 
2. pop() 取出队尾元素
3. size() 
4. empty() 
5. front() 返回最前面的元素
6. back() 返回最后面的元素
(8)将数字转化为字符:
char s[4];
sprintf(s, "%8d%8d", 123, 4567);
(9)打印出系统错误信息。
 int ret = 0; 
 ret = pox_system("gzip -c /var/opt/I00005.xml > /var/opt/I00005.z"); 
 if(0 != ret) 
 { 
 　　Log("zip file failed: %s\n", strerror(errno)); //尝试打印出系统错误信息 
 } 
(10):vector<string>str:输出的问题;
     cout<<str[0]开始不能输出，才知道忘记加了#include<string>要不输不出字符串。
(11):string类型，目的:将数组中的数字连续输入string中。
		string str = "";
		for (i=0; i<numbers.size(); i++)
		{
			char s[4] = { 0 };
			sprintf(s, "%d", numbers[i]);
			str =str+s;
		}
(12):string类型中存放数字可以直接比较大小，不用转换成int类型。
(13):string 的函数:
size()和length();
push_back() 和 insert();
erase();
replace();
find();
sort(s.begin(),s.end())(地址);
strtok() & substr();
(14)int a=4;int b=a>>1;a值不变，b=2;如果b=a<<1;b=8;
(15)list<int>circle
   list<int>::iterator next定义了一个指向list函数的指针。
back() 返回最后一个元素 
begin() 返回指向第一个元素的迭代器(指针)
clear() 删除所有元素
 empty() 如果list是空的则返回
end() 返回末尾的迭代器(不是最后一个元素，是最后一个元素的下一个指针) 
erase() 删除一个元素
front() 返回第一个元素 
get_allocator() 返回list的配置器 
insert() 插入一个元素到list中
 max_size() 返回list能容纳的最大元素数量
 merge() 合并两个list 
pop_back() 删除最后一个元素 
pop_front() 删除第一个元素 
push_back() 在list的末尾添加一个元素 
push_front() 在list的头部添加一个元素
sort()排序。
(16)sprintf(sSttl_brno,"%.3s001",sOpn_br_no);
    fprintf()函数主要用于格式化信息输出到指定的文件流中
    char esb_req_head[1024]={0};
    sprintf(esb_req_head,"%-4.4s","1001");  	
    sprintf(esb_req_head+strlen(esb_req_head),"%-16.16s","6001");
	
    sprintf(esb_req_head+strlen(esb_req_head),"%-2.2s","05");
	
    sprintf(esb_req_head+strlen(esb_req_head),"%-10.10s","CBS");
(17)string to_string(int) 头文件string,将int型转化为string类型。C++中。
(18)sort()排序函数。bool compare(int a,int b)
{
return a>b;
}vector<int>data;sort(data.begin(),data.end(),compare);
(19)ascii转化为BCD码，比如char ascii[12] = { '1', '2'};本来它的存储是0X31，0X32，两个字节,但是转化为12  BCD编码就是0X12，两个以上的字符这样可以节省空间，比较好用。
(20)int 最小值:INT_MIN，最大值:INT_MAX 
(21)(2+x)^(~3)   ^异或的意思。~取反的意思。
(22)scanf("%d",&m)!=EOF 判断是否有输入。
(23)64位系统的地址占8个字节，32位系统的地址占4个字节。
(24)struct node{
    int x,y,k,step;
    node(int x,int y,int k,int step):x(x),y(y),k(k),step(step)()
};这样写就可以直接调用node(x,y,k,step);
(25):                   //if('a'<=G[nx][ny]&&G[nx][ny]<='z') key=key|(1<<(G[nx][ny]-'a'));
                        //if('A'<=G[nx][ny]&&G[nx][ny]<='Z'&&(key&(1<<(G[nx][ny]-'A')))==0) continue;
			if (G[nx][ny]>='a'&&G[nx][ny] <= 'z') key = key|(1 << (G[nx][ny] - 'a'));
			if (G[nx][ny]>='A'&&G[nx][ny] <= 'Z' && (key&(1<<(G[nx][ny]-'A')) == 0)) continue;
最好写成上面一串形式的，要不会出错。
(26)TreeNode *head=new TreeNode(pre[0]);为值为pre[0]的数申请一个内存地址空间。
    开头计算连续的字符
(27)strcspn() 用来计算字符串 str 中连续有几个字符都不属于字符串 accept 特别注意都是从开头计算连续的字符。
    strspn() 函数用来计算字符串 str 中连续有几个字符都属于字符串 accept，
  #include <string.h>
 
  main()
 
  {
   
    char *str = "Linux was first developed for 386/486-based pcs.";
    char *str1 = " was first developed for 386/486-based pcs.";
 
    printf("%d\n", strcspn(str, " "));

    printf("%d\n", strspn(str, " "));

    printf("%d\n", strspn(str1, " "));
 
    printf("%d\n", strcspn(str, "/-"));
 
    printf("%d\n", strcspn(str, "1234567890"));
 
  }
 
 执行结果：
 
 5 //只计算到" "的出现, 所以返回"Linux"的长度
 
 0 // 从开始计算连续" "的出现的次数。(特别注意)

 1 // 从开始计算连续" "的出现的次数。(特别注意)

 33 //计算到出现"/"或"－", 所以返回到"6"的长度
 
 30 // 计算到出现数字字符为止, 所以返回"3"出现前的长度
(28)排列组合(见字符串排列组合)
通过采用循环套递归，首先让他执行到尾部，然后从尾部到首部这样开始。
比如输入abc
执行结束后为abc,acb,bac,bca,cba,cab。
(29)sort()函数，三个参数时。
求正数数组中的数拼接成最小的一个数，sort()中第三个参数可以设定怎样比较排序，同时第三个参数定义函数为静态函数。
static bool cmp(int a,int b)
    {
        string A="";
        string B="";
        A=A+to_string(a);
        A=A+to_string(b);
        B=B+to_string(b);
        B=B+to_string(a);
        return A<B;
    }
string PrintMinNumber(vector<int> numbers) {
        string answer="";
        sort(numbers.begin(),numbers.end(),cmp);
        for(int i=0;i<numbers.size();i++)
        {
            answer=answer+to_string(numbers[i]);
        }
        return answer;
    }
(30)string to_string (int val);将int类型转化为string类型数据。
(31)char cPasswd[6+1] ;

	memset(cPasswd, 0x0, sizeof(cPasswd));
(32)memset(sTmp_str, 0, sizeof(sTmp_str));
		fgets(sTmp_str,1023,fp);从一个文本文件中读取一串字符，遇到\n结束或者1023结束,末尾再加\0;
(33)
class TA
{
   public:
      int &m_i;
   TA(int &i):m_i(i)
     {
        cout<<"TA()构造函数被执行"<<endl;
      }
   TA(const TA &ta):m_i(ta.m_i)
      {
         cout<<"TA()拷贝构造函数被执行"<<endl;
       }
    ~TA()
       {
          cout<<"~TA()析构函数被执行"<<endl;
        }
     void operator()()
       {
       }
}
a)相当于一个#include"TA.h"文件，
构造函数相当于为创建的对象分配存储空间。
拷贝构造函数相当于复制一个构造函数，比如在一个不输主函数中定义了一个对象，想要传给主函数时由于其为局部对象，所以
借用拷贝构造函数来实现复制。
析构函数相当于为函数释放内存空间。
b)this指针，在每一个成员函数中都拥有一个this指针，这样能确保不同对象调用函数时的单对单性
c)外部变量，当在两个.cpp文件中都必须调用同一个变量，在一个.cpp文件定义后分配空间后，同一个项目下一个.cpp文件使用
加extern 这样就可以使用，不需再分配空间。否则会报"重复定义"错误。