WINDOWS的一般程序是用什么語言編寫的？

可以肯定的說基本上都是c和c++語言。。。。你說c++語言沒有界面是你的概念理解錯誤，語言本身都是不提供所謂“界面”的，提供界面的是某些函數(shù)庫或者類庫，比如win32api函數(shù)或者mfc，qt的庫，就像標準庫會提供cin和cout一樣。你只用了標準庫，當然沒界面了。另外千千靜聽絕不會是c#寫的，因為從沒見過運行個千千還需要framework支持的（莫非我的版本老了？？）

為晉中等地區(qū)用戶提供了全套網(wǎng)頁設(shè)計制作服務(wù)，及晉中網(wǎng)站建設(shè)行業(yè)解決方案。主營業(yè)務(wù)為成都網(wǎng)站設(shè)計、網(wǎng)站制作、晉中網(wǎng)站設(shè)計，以傳統(tǒng)方式定制建設(shè)網(wǎng)站，并提供域名空間備案等一條龍服務(wù)，秉承以專業(yè)、用心的態(tài)度為用戶提供真誠的服務(wù)。我們深信只要達到每一位用戶的要求，就會得到認可，從而選擇與我們長期合作。這樣，我們也可以走得更遠！

C++讀取BMP圖像

#includemath.h

#include iomanip.h

#include stdlib.h

#include windows.h

#include stdio.h

#include stdlib.h

#include iostream.h

#include fstream.h

//---------------------------------------------------------------------------------------

//以下該模塊是完成BMP圖像(彩色圖像是24bit RGB各8bit)的像素獲取，并存在文件名為xiang_su_zhi.txt中

unsigned char *pBmpBuf;//讀入圖像數(shù)據(jù)的指針

int bmpWidth;//圖像的寬

int bmpHeight;//圖像的高

RGBQUAD *pColorTable;//顏色表指針

int biBitCount;//圖像類型，每像素位數(shù)

//-------------------------------------------------------------------------------------------

//讀圖像的位圖數(shù)據(jù)、寬、高、顏色表及每像素位數(shù)等數(shù)據(jù)進內(nèi)存，存放在相應(yīng)的全局變量中

bool readBmp(char *bmpName)

{

FILE *fp=fopen(bmpName,"rb");//二進制讀方式打開指定的圖像文件

if(fp==0) return 0;

//跳過位圖文件頭結(jié)構(gòu)BITMAPFILEHEADER

fseek(fp, sizeof(BITMAPFILEHEADER),0);

//定義位圖信息頭結(jié)構(gòu)變量，讀取位圖信息頭進內(nèi)存，存放在變量head中

BITMAPINFOHEADER head;

fread(head, sizeof(BITMAPINFOHEADER), 1,fp); //獲取圖像寬、高、每像素所占位數(shù)等信息

bmpWidth = head.biWidth;

bmpHeight = head.biHeight;

biBitCount = head.biBitCount;//定義變量，計算圖像每行像素所占的字節(jié)數(shù)（必須是4的倍數(shù)）

int lineByte=(bmpWidth * biBitCount/8+3)/4*4;//灰度圖像有顏色表，且顏色表表項為256

if(biBitCount==8)

{

//申請顏色表所需要的空間，讀顏色表進內(nèi)存

pColorTable=new RGBQUAD[256];

fread(pColorTable,sizeof(RGBQUAD),256,fp);

}

//申請位圖數(shù)據(jù)所需要的空間，讀位圖數(shù)據(jù)進內(nèi)存

pBmpBuf=new unsigned char[lineByte * bmpHeight];

fread(pBmpBuf,1,lineByte * bmpHeight,fp);

fclose(fp);//關(guān)閉文件

return 1;//讀取文件成功

}

//-----------------------------------------------------------------------------------------

//給定一個圖像位圖數(shù)據(jù)、寬、高、顏色表指針及每像素所占的位數(shù)等信息,將其寫到指定文件中

bool saveBmp(char *bmpName, unsigned char *imgBuf, int width, int height,

int biBitCount, RGBQUAD *pColorTable)

{

//如果位圖數(shù)據(jù)指針為0，則沒有數(shù)據(jù)傳入，函數(shù)返回

if(!imgBuf)

return 0;

//顏色表大小，以字節(jié)為單位，灰度圖像顏色表為1024字節(jié)，彩色圖像顏色表大小為0

int colorTablesize=0;

if(biBitCount==8)

colorTablesize=1024;

//待存儲圖像數(shù)據(jù)每行字節(jié)數(shù)為4的倍數(shù)

int lineByte=(width * biBitCount/8+3)/4*4;

//以二進制寫的方式打開文件

FILE *fp=fopen(bmpName,"wb");

if(fp==0) return 0;

//申請位圖文件頭結(jié)構(gòu)變量，填寫文件頭信息

BITMAPFILEHEADER fileHead;

fileHead.bfType = 0x4D42;//bmp類型

//bfSize是圖像文件4個組成部分之和

fileHead.bfSize= sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER)

+ colorTablesize + lineByte*height;

fileHead.bfReserved1 = 0;

fileHead.bfReserved2 = 0;

//bfOffBits是圖像文件前3個部分所需空間之和

fileHead.bfOffBits=54+colorTablesize;

//寫文件頭進文件

fwrite(fileHead, sizeof(BITMAPFILEHEADER),1, fp);

//申請位圖信息頭結(jié)構(gòu)變量，填寫信息頭信息

BITMAPINFOHEADER head;

head.biBitCount=biBitCount;

head.biClrImportant=0;

head.biClrUsed=0;

head.biCompression=0;

head.biHeight=height;

head.biPlanes=1;

head.biSize=40;

head.biSizeImage=lineByte*height;

head.biWidth=width;

head.biXPelsPerMeter=0;

head.biYPelsPerMeter=0;

//寫位圖信息頭進內(nèi)存

fwrite(head, sizeof(BITMAPINFOHEADER),1, fp);

//如果灰度圖像，有顏色表，寫入文件

if(biBitCount==8)

fwrite(pColorTable, sizeof(RGBQUAD),256, fp);

//寫位圖數(shù)據(jù)進文件

fwrite(imgBuf, height*lineByte, 1, fp);

//關(guān)閉文件

fclose(fp);

return 1;

}

//----------------------------------------------------------------------------------------

//以下為像素的讀取函數(shù)

void xiang_su_du_qu()

{

//讀入指定BMP文件進內(nèi)存

char readPath[]="nv.BMP";

readBmp(readPath);

//輸出圖像的信息

cout"width="bmpWidth" height="bmpHeight" biBitCount="biBitCountendl;

//循環(huán)變量，圖像的坐標

//每行字節(jié)數(shù)

int lineByte=(bmpWidth*biBitCount/8+3)/4*4;

//循環(huán)變量，針對彩色圖像，遍歷每像素的三個分量

int m=0,n=0,count_xiang_su=0;

//將圖像左下角1/4部分置成黑色

ofstream outfile("圖像像素.txt",ios::in|ios::trunc);

if(biBitCount==8) //對于灰度圖像

{

//------------------------------------------------------------------------------------

//以下完成圖像的分割成8*8小單元，并把像素值存儲到指定文本中。由于BMP圖像的像素數(shù)據(jù)是從

//左下角：由左往右，由上往下逐行掃描的

int L1=0;

int hang=63;

int lie=0;

//int L2=0;

//int fen_ge=8;

for(int fen_ge_hang=0;fen_ge_hang8;fen_ge_hang++)//64*64矩陣行循環(huán)

{

for(int fen_ge_lie=0;fen_ge_lie8;fen_ge_lie++)//64*64列矩陣循環(huán)

{

//--------------------------------------------

for(L1=hang;L1hang-8;L1--)//8*8矩陣行

{

for(int L2=lie;L2lie+8;L2++)//8*8矩陣列

{

m=*(pBmpBuf+L1*lineByte+L2);

outfilem" ";

count_xiang_su++;

if(count_xiang_su%8==0)//每8*8矩陣讀入文本文件

{

outfileendl;

}

}

}

//---------------------------------------------

hang=63-fen_ge_hang*8;//64*64矩陣行變換

lie+=8;//64*64矩陣列變換

//該一行（64）由8個8*8矩陣的行組成

}

hang-=8;//64*64矩陣的列變換

lie=0;//64*64juzhen

}

}

//double xiang_su[2048];

//ofstream outfile("xiang_su_zhi.txt",ios::in|ios::trunc);

if(!outfile)

{

cout"open error!"endl;

exit(1);

}

else if(biBitCount==24){//彩色圖像

for(int i=0;ibmpHeight;i++)

{

for(int j=0;jbmpWidth;j++)

{

for(int k=0;k3;k++)//每像素RGB三個分量分別置0才變成黑色

{

//*(pBmpBuf+i*lineByte+j*3+k)-=40;

m=*(pBmpBuf+i*lineByte+j*3+k);

outfilem" ";

count_xiang_su++;

if(count_xiang_su%8==0)

{

outfileendl;

}

//n++;

}

n++;

}

}

cout"總的像素個素為:"nendl;

cout"----------------------------------------------------"endl;

}

//將圖像數(shù)據(jù)存盤

char writePath[]="nvcpy.BMP";//圖片處理后再存儲

saveBmp(writePath, pBmpBuf, bmpWidth, bmpHeight, biBitCount, pColorTable);

//清除緩沖區(qū)，pBmpBuf和pColorTable是全局變量，在文件讀入時申請的空間

delete []pBmpBuf;

if(biBitCount==8)

delete []pColorTable;

}

void main()

{

xiang_su_du_qu();

}

在vb.net中，使用TabCoutrol，如何在打開標簽的時候textbox3得到焦點？

Private Sub TabControl1_SelectedIndexChanged(sender As Object, e As EventArgs) Handles TabControl1.SelectedIndexChanged

If TabControl1.SelectedIndex = 1 Then TextBox3.Focus() '如果選項卡的索引為1，那么文本框3獲得焦點

End Sub

n重循環(huán)問題： 怎樣寫一個n重的循環(huán)？n是輸入的值。語言不限，（最好是C\c++ 、vb.net 或c#的）

誰告訴你這種問題要用n重循環(huán)來寫了…………………………

要是n=10000，你還不把電腦憋炸了…………………………

編程的時候要盡量減少循環(huán)的層數(shù)，5以內(nèi)沒關(guān)系，但要是你打算弄個n層的循環(huán)，那就扯死了……

順便一說，沒有這種寫法。

不過就你說的這個問題而言，不是n重，而是2重……無非多設(shè)一個“已經(jīng)選過的數(shù)字”的數(shù)組，查一下就好了。

for n次循環(huán)輸出n個數(shù)

for 從1到9

if 還沒輸出過 輸出并添加至已輸出數(shù)組

else 跳過去

這是兩重循環(huán)，可不是n重循環(huán)……不要想n重循環(huán)……

vb編程計算某年某月某日是星期幾

VB內(nèi)置的Weekday函數(shù)就可以返回星期.

Weekday(date[, firstdayofweek])

-- date: 必要; Date類型; 要求的日期

-- firstdayofweek: 可選; vbDayOfWeek類型; 定義每周第一天(默認為星期天)

Weekday返回一個Integer, 代表每周第幾天.

============================================

WeekdayName(weekday[, abbreviate][, firstdayofweek])

-- weekday: 必要; Long類型; 每周第幾天

-- abbreviate: 可選; Boolean類型; 表示星期的名稱是否被縮寫(默認為False)

-- firstdayofweek: 可選; vbDayOfWeek類型; 定義每周第一天(默認為星期天)

WeekdayName返回一個String, 如"星期一", 但根據(jù)不同的系統(tǒng), 也會返回如"Monday".

============================================

你也可以不用WeekdayName自己得到星期名

Choose(Weekday(#8/8/2008#, vbMonday), "星期一", "星期二", "星期三", "星期四", "星期五", "星期六", "星期日")

3. 用任意一種編程語言（C/C++/Java/C#/VB.NET）寫出任意一種你所知的排序算法（比如：冒泡排序， 歸并排

#includestdio.h

#includestdlib.h

void BubbleSort(int a[], const int first, const int last);//冒泡排序

void InsertSort(int a[], const int first, const int last);//插入排序

void SelectSort(int a[], const int first, const int last);//選擇排序

void MergeSort(int a[], const int p, const int r);//合并排序

void QuickSort(int a[],const int p,const int r);//快速排序

void ShellSort(int a[],const int p,const int r,const int dlta[],const int t);//希爾排序

void HeapSort(int a[],const int p, int r); //堆排序

void StoogeSort(int a[],const int p,const int r);//Stooge排序(不用)算法復(fù)雜度沒算清楚

void main()

{

//插入排序算法

int a[11] = {6,4,5,3,2,1};

int dlta[]={9,5,3,2,1};

//BubbleSort(a,0,5);

//InsertSort(a,0,5);

//SelectSort(a,0,5);

//MergeSort(a,0,5);

//QuickSort(a,0,5);

//ShellSort(a,0,5,dlta,5);

HeapSort(a,0,5);

//StoogeSort(a,0,5);

for(int i=0; i=5;i++)

{

printf("%d ",a[i]);

}

}

/************************冒泡排序***********************/

void BubbleSort(int a[], int first, int last)

{

//實現(xiàn)對數(shù)組a[]中a[first]到a[last]升序的“冒泡”排序

int i,j,temp;

for(i=first; i=last; i++)

{

for(j=first; j last-i; j++)

{

if(a[j] a[j+1])

{

temp = a[j];

a[j] = a[j+1];

a[j+1] = temp;

}

}

}

}

/************************插入排序***********************/

void InsertSort(int a[], int first, int last)

{

//實現(xiàn)對數(shù)組a[]中a[first]到a[last]升序的“插入”排序

//最壞情況為n的平方，，多用于小數(shù)組

int i,j,temp;

for(i=first+1; i=last; i++)

{

temp = a[i];

j = i - 1;

while((j = 0) (a[j] temp))

{

a[j+1] = a[j];

j--;

}

a[j+1] = temp;

}

}

/************************選擇排序***********************/

void SelectSort(int a[], int first, int last)

{

//實現(xiàn)對數(shù)組a[]中a[first]到a[last]升序的“選擇”排序

int i, j, temp, num;

for(i=first; ilast; i++)

{

num = i;

for(j=i+1; j=last; j++)

{

if(a[j] a[num])

{

num = j;

}

}

if(i != num)

{

temp = a[num];

a[num] = a[i];

a[i] = temp;

}

}

}

/************************合并排序***********************/

void Merge(int a[],const int p,const int q,const int r)

{

//合并排序算法中的實現(xiàn)合并的子程序

int iLLength,iRLength;

int *L, *R, i, j, k;

iLLength = q - p + 1;

iRLength = r - q;

L = (int *)malloc(iLLength*sizeof(int)); //或者 C++中 new int[iLLength];

R = (int *)malloc(iRLength*sizeof(int)); //或者 C++中 new int[iRLength];

if(L == 0 || R== 0)

{

printf("內(nèi)存分配失?。。?！");

return;

}

for(i=0; iiLLength; i++)

{

L[i] = a[p+i];

}

for(j=0; jiRLength; j++)

{

R[j] = a[q+j+1];

}

i = 0;

j = 0;

for(k=p; k=r; k++)

{

if((iiLLength) (jiRLength) (L[i]=R[j]) || (j == iRLength))

{

a[k] = L[i];

i++;

}

else if(jiRLength)

{

a[k] = R[j];

j++;

}

}

free(R);free(L);

}

void MergeSort(int a[],const int p,const int r)

{

//合并排序算法-主程序

//n*lg(n),系數(shù)較小

int q;

if(pr)

{

q = (p+r)/2;

MergeSort(a,p,q);

MergeSort(a,q+1,r);

Merge(a,p,q,r);

}

}

/************************Stooge排序***********************/

void StoogeSort(int a[],const int p,const int r)

{

//Stooge算法

int temp, k;

if(a[p]a[r])

{

temp = a[p];

a[p] = a[r];

a[r] = temp;

}

if((p+1) = r)

{

return;

}

k = (r-p+1)/3;

StoogeSort(a,p,r-k);

StoogeSort(a,p+k,r);

StoogeSort(a,p,r-k);

}

/************************快速排序*********************/

int QuickPartition(int a[],const int p,const int r)

{

//快速排序的(關(guān)鍵)分治過程

int temp, x, i, j;

x = a[r];

i = p - 1;

for(j=p; jr; j++)

{

if(a[j] = x)

{

i = i + 1;

temp = a[i];

a[i] = a[j];

a[j] = temp;

}

}

temp = a[i+1];

a[i+1] = a[r];

a[r] = temp;

return (i+1);

}

/*

void QuickSort(int a[],const int p,const int r)

{

//快速排序算法-主程序

//與下面的“尾遞歸實現(xiàn)方法”比較，缺點：右邊數(shù)組的遞歸不是必須的，增加了運行堆棧深度和調(diào)用開銷

int q;

if(p r)

{

q = QuickPartition(a, p, r);

QuickSort(a, p, q-1);

QuickSort(a, q+1, r);

}

}

*/

void QuickSort(int a[],int p,const int r)

{

//快速排序算法-主程序

//“尾遞歸實現(xiàn)方法”是對上面的快速排序主程序?qū)崿F(xiàn)的一種優(yōu)化

//系數(shù)較小,常用大數(shù)組

int q;

while(p r)

{

q = QuickPartition(a, p, r);

QuickSort(a, p, q-1);

p = q + 1;

}

}

/************************希爾排序**********************/

void ShellInsert(int a[],const int p,const int r, int dk)

{

//希爾排序算法的關(guān)鍵子程序-插入排序子程序

int i, j, temp;

for(i=p+dk; i=r; i++)

{

if(a[i] a[i-dk])

{

temp = a[i];

for(j=i-dk; ((j=0) (temp a[j])); j -= dk)

{

a[j+dk] = a[j];

}

a[j+dk] = temp;

}

}

}

void ShellSort(int a[],const int p,const int r,const int dlta[],const int t)

{

//希爾排序算法-主程序

//按增量序列dlta[]中的前t個增量，實現(xiàn)對數(shù)組a[]中a[p]到a[r]的排序

//dlta[]可能取值如：1,2,3,5,9 dala[k]=2^(t-k+1)-1 其中0=k=t=ld(b-1)

//增量序列的最后一個值必須是1

//增量序列中的值沒有除1以外的因子， 其精確時間復(fù)雜度：數(shù)學上尚未解決的難題

int k;

for(k=0; kt; k++)

{

ShellInsert(a,p,r,dlta[k]);

}

}

/************************堆排序***********************/

//堆排序，不如快速排序

//但是可用其來實現(xiàn)“優(yōu)先級隊列”

int Parent(int i)

{

return ((i+1)/2-1);

}

int Right(int i)

{

return (2*(i+1)-1);

}

int Left(int i)

{

return (2*(i+1));

}

void Max_Heapify(int a[],const int hplast,const int i)

{

int l, r,largest,temp;

l = Left(i);

r = Right(i);

largest = ((l=hplast) (a[l]a[i])) ? l:i;

if((r=hplast) (a[r]a[largest]))

{

largest = r;

}

if(largest != i)

{

temp = a[i];

a[i] = a[largest];

a[largest] = temp;

Max_Heapify(a,hplast,largest);

}

}

void Build_Max_Heap(int a[],const int p, const int r)

{

int i;

for(i = (p+r)/2; i=p; i--)

{

Max_Heapify(a,r,i);

}

}

void HeapSort(int a[],const int p, int r)

{

int i,temp;

Build_Max_Heap(a,p,r);

for(i = r; i p; i--)

{

temp = a[p];

a[p] = a[i];

a[i] = temp;

r -= 1;

Max_Heapify(a,r,0);

}

}