学习c++ 2013-11-19

．下面两个程序中有全局变量，注意全局变量的生存周期及存储类型

#include "stdafx.h"
#include <iostream>
using namespace std;

int a=3,b=5;

int max_t(int a,int b);


int main(int argc, char* argv[])
{
	int a=8;
	cout<<max_t(a,b)<<endl;	
	return 0;
}

int max_t(int a,int b)
{
	int c;
	c=a>b?a:b;
	return c;
}

这是一个作用域的问题。一个声明将一个名字引进一个作用域；局部变量（通常在函数中定义）的作用域是从声明的那一点开始，直到这个声明所在的块结束为止（一个块就是由{}围起来的一段代码）。全局变量（在所有函数、类、命名空间之外定义）的作用域从声明的那一点开始，直到这个声明所在的文件的结束。与全局变量重名的局部变量可以屏蔽全局变量，如果想在块内使用全局变量需要通过作用域解析运算符::引用。 见下例：

#include <iostream>
using namespace std;
int x ;   //定义一个全局变量x
int main()
{
    int x ; //屏蔽全局变量x
    cout<< "Global x Initial value = "<< ::x << endl;
    cout<< "Local x Initial value = "<< x << endl;
    x = 5;          //对局部变量x赋值
    ::x = 6;      //通过作用域解析运算符::引用全局变量x,并且改变其值
    cout<< " After assignment Global x = " << ::x << endl;
    cout<< "After assignment Local x = " << x <<endl;
    return 0;
}
上述例子输出结果为：
Global x Initial value = 0
Local x Initial value = 11239412
After assignment Global x = 6
After assignment Local x = 5
从上面的例子还可以看出，如果没有显示初始化，那么全局变量、静态局部变量等静态对象会被自动初始化为适当类型的0，而局部对象（也称为自动对象）和在自由存储区里建立的对象（动态对象或者堆对象）将不会被初始化。

静态成员的用法

#include "stdafx.h"
#include "stdio.h"
#include "iostream"
#include "string.h"
using namespace std;

class Student
{
public:
	Student(char name1[],int sco)
	{
		strcpy_s(name,name1);
		score=sco;
	}

	void total()
	{
		sum+=score;
		count++;
	}
	static double aver()
	{
		return (double)Student::sum/Student::count;
	}
private:
	char name[20];
	int score;
	static int sum,count;

};

int Student::sum=0;
int Student::count=0;

int _tmain(int argc, _TCHAR* argv[])
{
	Student stu[5]={Student("ma",89),Student("hu",90),Student("li",88),Student("ly",78),Student("ku",94)};
	for(int i=0;i<5;i++)
	{
		stu[i].total();

	}
	cout<<"avg="<<Student::aver()<<endl;

	cin.get();
}

静态成员

基本介绍

在c++类中声明成员时可以加上static 关键字，这样声明的成员就叫做静态成员（包括 数据成员和成员函数）。例如：

class test{

public:

test(){}

~test(){}

public:

//静态成员函数

static int getCount(){

return m_nCount;

}

private:

//静态数据成员

static int m_nCount;

};

int test::m_nCount=0;

2区别对比

静态 数据成员和普通数据成员区别较大，体现在下面几点：

（1）普通 数据成员属于类的一个具体的对象，只有对象被创建了，普通数据成员才会被分配内存。而静态数据成员属于整个类，即使没有任何对象创建，类的静态数据 成员变量也存在。

（2）因为类的静态数据成员的存在不依赖与于任何类对象的存在，类的静态数据成员应该在代码中被显示的初始化，一定要在类外进行，例如上例。

（3）外部访问类的静态成员只能通过类名来访问，例如：test::getCount()。

（4）类的静态成员函数无法直接访问普通 数据成员（可以通过对象名间接的访问），而类的任何成员函数都可以访问类的静态数据成员。

（5）静态成员和类的普通成员一样，也具有public、protected、private3种访问级别，也可以具有返回值、const 修饰符等参数。

应用举例：

汽车制造商为统计汽车的产量，可以在在汽车类--car类中增加用于计数的静态数据成员变量，比如在某个类car中声明一个static int number;初始化为0。这个number就能被所有car的实例共用。在car类的 构造函数里加上number++，在car类的 析构函数里加上number--。那么每生成一个car的实例，number就加一，每销毁一个car的实例（汽车报废），number就减一，这样，number就可以记录在市场上car的实例个数。

判断是否闰年：4年一闰，100年不闰，400年在闰

#include "stdafx.h"
#include "stdio.h"
#include "iostream"

using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{
	int year;
	cin>>year;
	if((year%4==0&&year%100!=0)||year%400==0)
	{
		printf("%d是闰年",year);
	}
	else
	{
		printf("%d不是闰年",year);
	}

}

灯塔数量：

有一个8层灯塔，每层的灯数都是上一层的一倍，共有765盏灯，请求出灯塔每层中的灯数

#include "stdafx.h"
#include "stdio.h"
#include "iostream"

using namespace std;


int _tmain(int argc, _TCHAR* argv[])
{
	int n=1,m,sum;
	int myarray[8];
	while(1)
	{
		myarray[0]=m=n;
		sum=0;
		for(int i=1;i<8;i++)
		{
			m=m*2;
			myarray[i]=m;
			sum+=m;
		}
		sum+=n;
		if(sum==765)
		{
			for(int j=0;j<8;j++)
			{
				printf("第%d:层楼的灯数是%d:\n",j+1,myarray[j]);
			}
			break;
		}
		n++;
	}
	
	return 0;
}

乘法口诀表：

int _tmain(int argc, _TCHAR* argv[])
{
	int i,j;
	for(i=1;i<=9;i++)
	{
		for(j=1;j<=i;j++)
		{
			printf("%d*%d=%d\t",j,i,i*j);
			
		}
		printf("\n");
	}
	
	return 0;
}

效果如下：

百钱买白鸡

int _tmain(int argc, _TCHAR* argv[])
{
	int cock,hen,chick;
	for(cock=0;cock<=20;cock++)
	{
		for(hen=0;hen<=33;hen++)
		{
			for(chick=3;chick<=99;chick++)
			{
				if(5*cock+3*hen+chick/3==100&&cock+hen+chick==100&&chick%3==0)
					printf("鸡wen：%d,鸡母：%d，小鸡：%d\n",cock,hen,chick);
			}
        }
	}
		
	return 0;
}

效果如下：

彩球问题

int _tmain(int argc, _TCHAR* argv[])
{
	int i,j,count;
	printf("所有方案如下：\n");
	printf("序号   红色球   白色求   黑色求\n");
	count=1;
	for(i=0;i<=3;i++)
	{
		for(j=0;j<=3;j++)
		{
			if((8-i-j)<=6)
			{
				printf("%4d%8d%8d%8d\n",count++,i,j,8-i-j);
			}
		}
	}

	
	return 0;