C/C++ - 基础篇（下）

nds[0]=tnds[0]; // 结构体直接赋值的话，nds[0] 地址不变，数据变

void dfs(int sum)
{
    if(sum==all) return;
    for(int i=0;i<len;i++)
    {
        if(cnt[i]>0)
        {
            int vis[len]; mem(vis,0);
            vis[i]=1;
            dfs(sum+1);
            if(vis[i]==1)
            {
                // do something...
            }
        }
    }
}

int a = 30;
stringstream ss;
ss<<a; 
string s1 = ss.str();
cout<<s1<<endl; // 30
string s2; // char s3[100]; ss>>s3; 也可以转换 char[] 类型
ss>>s2;
cout<<s2<<endl; // 30

    printf("%f\n",1L/2);        // 0.000000
    printf("%f\n",1.0/2);       // 0.500000
    printf("%f\n",1.0L/2);      // -0.000000
    printf("%f\n",1.0F/2);      // 0.500000
    printf("%f\n",1F/2);        // 编译错误
    printf("%lf\n",1.0L/2);     // 0.500000
    printf("%lf\n",1L/2);       // 0.500000
    printf("%lf\n",1.0F/2);     // 0.000000

    string s1="10",s2="12";
    int a,b;
    stringstream ss;
    ss<<s1;
    ss>>a;
    cout<<a<<endl; // 10
    ss<<s2;
    ss>>b;
    cout<<b<<endl; // 随机值
    cout<<ss.str().capacity()<<endl; // 2
    ss.clear();
    cout<<ss.str().capacity()<<endl; // 2
    ss.str("");  // 一定要加引号才有效
    cout<<ss.str().capacity()<<endl; // 0
    ss<<s2;
    ss>>b;
    cout<<b<<endl; // 12

/* vec.clear() 与 vector<int>().swap(vec) 区别 */
vector<int> vec;
vec.push_back(12);
vec.clear();
cout<<vec[0]<<endl; // 12
vec.push_back(20);
cout<<vec[0]<<endl; // 20
vector<int>().swap(vec);
cout<<vec[0]<<endl; // 报错
// Ps：clear 表面清空，但是里面的内存并未释放，swap 彻底清空，释放全部内存，跟刚刚新生成的一样。
/* vector<int> 比较：元素是否相同，或者按字典序比较 */
puts(v1 == v2 ? "Yes" : "No");
/* vector.resize(n) 申请空间大小，直接可以使用 v[i] */
vector<int> v;
v.resize(100);
v[3]=15;
/* find(v.begin(),v.end(),泛型)-v.begin() */
// 找到则返回第一次出现的下标，若找不到，则返回 v.size()
push_back() 时预留空间不够用：要重新分配内存，并且拷贝当前已有的所有元素到新的内存区域。如果已有元素很多，这个操作将变的非常昂贵。
Ps：ector的内存管理策略是：一旦空间不足，则增长一倍，对于大数据量，这也许是一块不容小朝的资源。

typedef pair<int,int> pii;
queue<pii> q;
q.push(make_pair(i,j));
x=q.front().first, y=q.front().second; q.pop();

for(int i=0;i<len;i++)
{
    if(s[i]>='a' && s[i]<='z') s[i]=toupper(s[i]);      // 转大写
    else if(s[i]>='A' && s[i]<='Z') s[i]=tolower(s[i]); // 转小写
}

string s;
cout<<(s+'a')<<endl;

// 第 1 种方法
struct pq_cmp // 根据先到达的人先处理业务
{
    bool operator()(P p1,P p2)
    {
  // 它与正常的 sort_cmp 的思想反着来的
        return p1.ssum>p2.ssum; // 进入的时间：从小到大
    }
};
priority_queue<P,vector<P>,pq_cmp> pq;
// 第 2 种方法
struct node
{
    char a[20];
    int rk;
    friend bool operator<(node p1,node p2) // 注意写死：friend、< 
    {
        return p1.rk>p2.rk; // 从小到大
    }
};
priority_queue<node> pq;

//Robert is a child of John
char a[20],with[20],b[20];
scanf("%s%*s%*s%s%*s%s",a,with,b);
/*
a==Robert
with==child
b==John
*/

/* unordered_map / map 自定义排序 */
typedef pair<string,int> psi;
unordered_map<string,int> ump;
int cmp(psi p1,psi p2)
{
    if(p1.second==p2.second) return p1.first<p2.first;
    return p1.second>p2.second;
}
vector<psi> vec(ump.begin(),ump.end());
sort(vec.begin(),vec.end(),cmp);
// Ps：map：红黑树；unordered_map：hash 散列表。
/* 泛型里面用 char* 替代 string 以及 map 插入时排序自定义 */
struct cmp
{
    bool operator()(const char* s1,const char* s2) const
    {
        return strcmp(s1,s2)<0; // default：map 根据 key 排序（字典序）
    }
};
map<char*,int,cmp> mp;
mp.clear();
char rr[100],rr1[100];
rr1[0]=rr[0]='a';
rr[1]='b';
rr1[2]=rr[2]='c';
mp[rr]=10;
rr1[1]='a';
mp[rr1]=12;
for(map<char*,int>::iterator it=mp.begin();it!=mp.end();it++)
    cout<<it->first<<endl;
/* map / unordered_map 不要轻易使用 size() 函数 */
// 如果中途在比较的时候，有些新的ump[i]原本没有存储的会被创建，导致size会扩增
if(ump[i]!=1)
{...}
printf("%d",ump.size());
/* map 插入自定义排序重写 */
/* C++ STL 中 Map 的按 Key 排序 */
// map这里指定less作为其默认比较函数(对象)，所以我们通常如果不自己指定Compare，map中键值对就会按照Key的less顺序进行组织存储。
map<string, int, less<string> > mp; // default ~ map<string, int> mp;
map<string, int, greater<string> > mp;
// 自定义
struct cmp
{
    bool operator()(const string& k1, const string& k2)
    {
        return k1.length() < k2.length();
    }
};
map<string, int, cmp> mp;
/* C++ STL 中 Map 的按 Value 排序 */
// 待更新...
/* erase(it) or erase(key) or erase(mp.begin(),mp.end()) */

cout<<isalpha('A')<<endl; // 1
cout<<isalpha('a')<<endl; // 2
cout<<islower('A')<<endl; // 0
cout<<islower('a')<<endl; // 2
cout<<isupper('A')<<endl; // 1
cout<<isupper('a')<<endl; // 0
cout<<isdigit('a')<<endl; // 0
cout<<isdigit('1')<<endl; // 1
cout<<isalnum('a')<<endl; // 2
cout<<isalnum('B')<<endl; // 1
cout<<isalnum('1')<<endl; // 4
cout<<isalnum('.')<<endl; // 0

int a[200],b[200],len=0;
a[len]=b[len++]=1; // a[1]==b[0]==1
a[len++]=b[len]=1; // a[0]==b[1]==1

1、说到这那到底hash_set与unordered_set哪个更好呢？实际上unordered_set在C++11的时候被引入标准库了，而hash_set并没有，所以建议还是使用unordered_set比较好，这就好比一个是官方认证的，一个是民间流传的。
2、set.count():O(logn); unordered_set.count() 比 set.count() 再快 4 倍左右。
3、multiset 可插入重复的值，其他用法与 set 类似。
/* set - count、insert().second */
set<int> st;
int ans=st.count(1); // st 中 1 出现的次数
bool f=st.insert(1).second; // 先插入试试，最后返回是否插入成功
/* set 自定义排序 */
struct node
{
    int val,cnt;
    node(int val,int cnt):val(val),cnt(cnt){}
    bool operator<(const node &nd)const
    {
        //return false 数据插入失败，而不是（插入成功，只是位置不一样）。
        return cnt!=nd.cnt ? cnt>nd.cnt : val<nd.val ;
    }
};
set<node> st;

for(int i=0;i<4;i++)
{
    for(int i=1;i<3;i++)
        printf("%d\n",i);
}
/*
1
2
1
2
1
2
1
2
*/

#define add(x,y) x+y // 不是计算好后返回，而是先返回好表达式再计算
printf("%d\n",add(1,2*add(3,4))); // 11
#define P 3
#define f(a) P*a*a
printf("%d\n",f(3+5)); // 3*3+5*3+5==29
#define ABC(x) x*x
int a, k=3;
a = ++ABC(k+1); //9
// 由于带参宏不会对参数自行添加括号运算，因此a 的计算展开式可写为 ++k+1*k+1 这样就很明显了，由于运算优先级的关系，先执行++k，即k先进行自加，k的值变成了4，然后a=4+1*4+1，结果就为9啦~

cout<<setw(5)<<setfill('0')<<a[i];
// 等价于
printf("%05d",a[i]);

node nd;
// 等价于
node nd();

1、foo(function object oriented)：面向对象编程的函数，有时候也不知道取什么名字，就代表“张三、李四”的味道。

node *left,*right; // T
node* left, right; // F

int a=2;
printf("%f\n",a*1.0/3); // 不推荐
printf("%f\n",a/3.0);   // 推荐

printf("%2d\n",1); //空1

/* 遍历倒序 */
for(set<int>::reverse_iterator it=st.rbegin(); it!=st.rend(); it++)
{
    cout<<*it<<endl;
}

static int a=0;
int main()
{
    return 0;
}
等价于
void fun()
{
    static int a=0;
}
int main()
{
    return 0;
}