(C++)一維陣列運算：兩陣列相加。

class 不是這般濫用的！

2009-11-22 23:20:54 補充：
看到提問者可能陷入比得了H1N1更暈的情境，
實在不忍心，遂提一帖解藥，盼能及時給你清心醒腦。
阿彌陀佛，善哉！善哉！

這應是想做模擬大數加法吧！
題目所提示的，是用一個位數的陣列來模擬，雖簡易，但效率較差。
本想改成四位數的陣列來開處方，但恐提問者一時不能意會，故作罷，
先以能救命為第一考量，故仍以題目的一個位數方式來處斷。

題目的A陣列，姑且叫它被加數，此例為10個位數，
B陣列為加數，同為10個位數。
由於累加後的結果可能會變成11位數，故A，B，C陣列皆設為11個元素。
又因陣列每一元素僅存一個位數，故用char 已夠用。
A[0]是最高位，A[SIZE-1]是個位。

為了力求簡易，故主程式在最後顯示結果時，不考慮前導零的問題
（本例不會發生，但其他應用時可能會碰到）
盼提問者能先就簡單的情境完全理解後，再求增益其日臻完備，才是學習之道。

示範程式如下，是大數加法最基礎的樣子，請參考，盼能有所裨益。

#include <stdio.h>
#include <stdlib.h>

#define SIZE 11
void nAdd(char *a, char *b, char *c, int len);

int main()
{
char A[SIZE] = {0,1,2,3,4,5,6,7,8,9,0}; //被加數
char B[SIZE] = {0,9,8,7,6,5,3,2,1,0,0}; //加數
char C[SIZE] = {0};//和
int i;

nAdd(A, B, C, SIZE); //呼叫大數加法函式

for (i = 0; i < SIZE; ++i) //由最高位起印出每個位數的值
printf("%d", C[i]);
printf("\n");
system("pause");
return 0;
}

void nAdd(char *a, char *b, char *c, int len) {
int i, carry = 0;//carry是進位
for(i = len - 1; i >= 0; --i) //從個位數加起
{
c[i] = a[i] + b[i] + carry;
if(c[i] < 10) //結果小於10,不用進位
carry = 0;
else { // 結果大於10,留其個位數，並設進位為1進位
c[i] = c[i] - 10;
carry = 1;
}
}
}

TO:jacob lee大大，說的好貼切...我看完 耗呆小綿羊大大的回答，
對初學的我來說 真的是很吃力...

高手絕對不會像小羊這樣寫！
太多太多的錯誤用法！
學它，在程式設計的路上，必死！！！

2009-11-20 05:49:10 補充：
死在哪些地方？

可讀性
可攜性
可維護性
執行速度
開發速度
．．．．

這些，都是重大慢性病！

2009-11-20 19:08:28 補充：
馬步不穩，練不好拳！

你最近一直用來回答的架構，
照示你對 class, NULL, constructor, compiler compatiblilty, OS 等的基本觀念根本有問題！

用這樣有多重問題的程式，回答一。二次，可謂好玩；
一直使用，被人指出有問題，還找藉口，
只能說，你不是不知它有問題，就是存心誤人子弟！

// Headers and Macros
#ifndef _MSC_VER
#undef NULL
#define NULL 0
#endif
#include <iostream>
#include <cstdlib>
using namespace std;
//
#include <list>
typedef list<int> Lint;
class CHW
{
public:
CHW(void)
{
int A[] = { 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 9};
int B[] = { 9, 2, 3, 4, 5, 9};
this->set( this->lint1, sizeof(A) / sizeof(A[0]), A);
this->set( this->lint2, sizeof(B) / sizeof(B[0]), B);
this->add();
int* C = new int[this->lint.size()];
size_t i = 0;
for ( Lint::iterator it = this->lint.begin(); it != this->lint.end(); it ++)
{
C[i ++] = (*it);
}
for ( i = 0; i < this->lint.size(); i ++)
{
cout<<C[i];
}
delete [] C;
cout<<endl;
}
// Rule of Three in C++
// 1. Copy Constructor
CHW(CHW& clone){}
// 2. Copy Assignment Operator
CHW& operator=(CHW& clone)
{
if ( this != &clone ){}
return *this;
}
// 3. Destructor
~CHW()
{
this->lint.clear();
this->lint1.clear();
this->lint2.clear();
}
void set( Lint& l, size_t szSize, int* nArr)
{
l.clear();
for ( size_t i = 0; i < szSize; i ++)
{
l.push_front(nArr[i]);
}
}
void add(void)
{
Lint longer = ( this->lint1.size() > this->lint2.size()? this->lint1: this->lint2);
Lint shorter = ( this->lint1.size() < this->lint2.size()? this->lint1: this->lint2);
this->lint.clear();
int n, carry = 0;
Lint::iterator it1 = longer.begin();
for ( Lint::iterator it2 = shorter.begin(); it2 != shorter.end(); it2 ++)
{
n = (*it1) + (*it2) + carry;
carry = n / 10;
this->lint.push_back(n % 10);
it1 ++;
}
for ( ; it1 != longer.end(); it1 ++)
{
n = (*it1) + carry;
carry = n / 10;
this->lint.push_back(n % 10);
}
this->lint.reverse();
}
private:
Lint lint, lint1, lint2;
};
//Main Function
#ifndef _MSC_VER
int
#else
void
#endif
main(int argc, char** argv)
{
//==START==//
CHW a;
//==END==//
system("PAUSE");
return
#ifndef _MSC_VER
EXIT_SUCCESS
#endif
;
}



2009-11-20 16:23:35 補充：
＝＿＿＝！
又不是在寫大型程式與 win32 視窗程式……