A+B for Matrices 及 C++ transform的用法

题目大意：给定两个矩阵，矩阵的最大大小是M*N（小于等于10），矩阵元素的值的绝对值小于等于100，求矩阵相加后全0的行以及列数。

 #include<iostream>
 using namespace std;
 #define N 10

 int main()
 {
     int n,m,i,j,a[N][N],b[N][N],s;
     while(cin>>m)
     {   if(m==) break;
         cin>>n;
         for(i=;i<m;i++)
             for(j=;j<n;j++)
                 cin>>a[i][j];
         for(i=;i<m;i++)
             for(j=;j<n;j++)
             {   cin>>b[i][j];
                 a[i][j]+=b[i][j];
             }
         s=;
         for(i=;i<m;i++)
         {   for(j=;j<n;j++)
                 if(a[i][j]!=) break;
             if(j==n) s++;
         }
         for(j=;j<n;j++)
         {   for(i=;i<m;i++)
                 if(a[i][j]!=) break;
             if(i==m) s++;
         }
         cout<<s<<endl;
     }
     return ;
 }

在网上看到一个大神用纯C++的思想写了如下代码：

 #include <iostream>
 #include <vector>
 #include <algorithm>
 using namespace std;

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

 int main(){
         vector<int> ivec1;
         vector<int> ivec2;

         int m, n, sum, data;
         while(cin >> m){
                 if( == m){
                         break;
                 }
                 cin >> n;
                 sum = m * n;
                 for(int i=; i!=sum; ++i){
                         cin >>  data;
                         ivec1.push_back(data);
                 }
                 for(int i=; i!=sum; ++i){
                         cin >>  data;
                         ivec2.push_back(data);
                 }
                 transform(ivec1.begin(), ivec1.end(), ivec2.begin(), ivec1.begin(), add);
                 int count = ;
                 int temp;
                 for(int i=; i!=m; ++i){
                         temp = ;
                         for (int j=; j!=n; ++j){
                                 temp += ivec1[i*n + j];
                         }
                         if ( == temp){
                                 count++;
                         }
                 }
                 for(int i=; i!=n; ++i){
                         temp = ;
                         for (int j=; j!=m; ++j){
                                 temp += ivec1[j*n + i];
                         }
                         if ( == temp){
                                 count++;
                         }
                 }
                 cout << count << endl;
                 ivec1.resize();
                 ivec2.resize();
         }
         return ;
 }

上面出现了transform的用法，在这里介绍下其用法：

 /*////////////////////////////////
 template < class InputIterator, class OutputIterator, class UnaryOperator >
   OutputIterator transform ( InputIterator first1,    // 源容器的起始地址
                             InputIterator last1,    // 源容器的终止地址
                             OutputIterator result,    // 目标容器的起始地址
                             UnaryOperator op );        // 函数指针
 // typedef 目标容器元素类型 (*UnaryOperator)(源容器元素类型);

 template < class InputIterator1, class InputIterator2,
            class OutputIterator, class BinaryOperator >
   OutputIterator transform ( InputIterator1 first1,        // 源容器1的起始地址
                             InputIterator1 last1,        // 源容器1的终止地址
                             InputIterator2 first2,        // 源容器2的起始地址，元素个数与1相同
                             OutputIterator result,        // 目标容器的起始地址，元素个数与1相同
                             BinaryOperator binary_op );    // 函数指针
 // typedef 目标容器元素类型 (*BinaryOperator)(源容器1元素类型，源容器2元素类型);
 //*////////////////////////////////

 #include <iostream>
 #include <algorithm>
 #include <vector>
 #include <string>
 using namespace std;

 int op_increase (int i)
 {
     return i+;
 }

 int op_sum (int i, int j)
 {
     return i+j;
 }

 int to_upper(int c)
 {
     if (islower(c))
     {
         return (c-);
     }

     return c;
 }

 int to_lower(int c)
 {
     if (isupper(c))
     {
         return c+;
     }

     return c;
 }

 int main () {
     vector<int> first;
     vector<int> second;
     vector<int>::iterator it;

     // set some values:
     for (int i=; i<; i++) first.push_back (i*); //  first: 10 20 30 40 50

     ///将first容器的元素加1赋值给second容器
     second.resize(first.size());        // allocate space !!!必须预先设置一个大小与first相同
     transform (first.begin(), first.end(), second.begin(), op_increase); // second: 11 21 31 41 51
     cout << "second contains:";
     for (it=second.begin(); it!=second.end(); ++it)
     {
         cout << " " << *it;
     }
     cout << endl;
     //*////////////////////////////////////////////

     ///将first容器的元素与second容器的元素相加，并将得到的结果重新赋值给first
     transform (first.begin(), first.end(), second.begin(), first.begin(), op_sum); //  first: 21 41 61 81 101
     cout << "first contains:";
     for (it=first.begin(); it!=first.end(); ++it)
         cout << " " << *it;
     cout << endl;
     //*//////////////////////////////////////////////////////////////////////////

     ///大小写转换/////////////////////////////////////
     string strsrc("Hello, World!");
     string strdest;
     strdest.resize(strsrc.size());        // !!!必须预先设置一个大小与strsrc相同
     transform(strsrc.begin(), strsrc.end(), strdest.begin(), to_upper);    // 转换为大写
     cout << strdest << endl;

     transform(strsrc.begin(), strsrc.end(), strdest.begin(), to_lower); // 转换为小写
     cout << strdest << endl;
     //*/////////////////////////////////////////

     return ;
 }

我们已经了解了一种区间元素交换swap_ranges函数，现在我们再来学习另外一种区间元素交换transform。该算法用于实现容器元素的变 换操作。有如下两个使用原型，一个将迭代器区间[first，last)中元素，执行一元函数对象op操作，交换后的结果放在 [result，result+（last-first)）区间中。另一个将迭代器区间[first1，last1)的元素*i，依次与 [first2，first2+（last-first）)的元素*j，执行二元函数操作binary_op(*i,*j)，交换结果放在 [result，result+（last1-first1)）。

函数原型：

1. template < class InputIterator, class OutputIterator, class UnaryOperator >
2. OutputIterator transform ( InputIterator first1, InputIterator last1,
3. OutputIterator result, UnaryOperator op );
4. template < class InputIterator1, class InputIterator2,
5. class OutputIterator, class BinaryOperator >
6. OutputIterator transform ( InputIterator1 first1, InputIterator1 last1,
7. InputIterator2 first2, OutputIterator result,
8. BinaryOperator binary_op );

     参数说明：

first1, last1
指出要进行元素变换的第一个迭代器区间 [first1,last1)。
first2
指出要进行元素变换的第二个迭代器区间的首个元素的迭代器位置，该区间的元素个数和第一个区间相等。
 
result
指出变换后的结果存放的迭代器区间的首个元素的迭代器位置
op
用一元函数对象op作为参数，执行其后返回一个结果值。它可以是一个函数或对象内的类重载operator()。
binary_op
用二元函数对象binary_op作为参数，执行其后返回一个结果值。它可以是一个函数或对象内的类重载operator()。

程序示例：

1. /*******************************************************************
2. * Copyright (C) Jerry Jiang
3. *
4. * File Name   : transform .cpp
5. * Author      : Jerry Jiang
6. * Create Time : 2012-4-29 22:22:18
7. * Mail        : jbiaojerry@gmail.com
8. * Blog        : http://blog.csdn.net/jerryjbiao
9. *
10. * Description : 简单的程序诠释C++ STL算法系列之十八
11. *               变易算法 : 区间元素交换 transform
12. *
13. ******************************************************************/
14. #include <iostream>
15. #include <algorithm>
16. #include <vector>
17. using namespace std;
18. int op_increase (int i) { return ++i; }
19. int op_sum (int i, int j) { return i+j; }
20. int main () {
21. vector<int> first;
22. vector<int> second;
23. vector<int>::iterator it;
24. // set some values:
25. for (int i=1; i<6; i++) first.push_back (i*10); //  first: 10 20 30 40 50
26. second.resize(first.size());     // allocate space
27. transform (first.begin(), first.end(), second.begin(), op_increase);
28. // second: 11 21 31 41 51
29. transform (first.begin(), first.end(), second.begin(), first.begin(), op_sum);
30. //  first: 21 41 61 81 101
31. cout << "first contains:";
32. for (it=first.begin(); it!=first.end(); ++it)
33. cout << " " << *it;
34. cout << endl;
35. return 0;
36. }