C++类的内联成员函数的放置，应该放在头文件中。那么这到底是为什么呢？仅仅是一种代码规范问题还是必须这样做呢？

    函数可以在多处声明，但只能在一个地方定义，不然就会出现重定义。大部分函数默认是外部链接，而inline函数默认为内部链

接。也就是说inline函数只能在本文件中使用，对其他文件是不可见的。一般我们使用某个类的时候，都是在文件中加

上该类的头文件，以便我们可以使用该类的接口。而我们类的成员函数的实现都是放在相应的.cpp文件中的，而在.h

文件中声明。这样我们便可以通过.h文件中的成员函数的声明找到其定义，继而使用成员函数了。但如果将inline函数

放在.cpp文件中，那么其只对.cpp文件有效，这样我们就无法访问它了。所以我们将其放在类的声明的头文件中，这

样通过包含该头文件来使用它。

下面写个实际的例子来说明一下，先把内联函数放到类声明的头文件中：
/*test.h*/ 
#ifndef TEST_H 
#define TEST_H 

#include <iostream> 
using std::cout; 
using std::endl; 

class test 
{ 
public: 
test():x(10){} 
inline void print(); 
void display (int y); 
private: 
int x; 
}; 

void test::print() 
{ 
cout << x << endl; 
} 

#endif 


/*test.cpp*/ 
#include <iostream> 
#include "test.h" 
using std::cout; 
using std::endl; 

void test::display(int y) 
{ 
cout << x * y << endl; 
} 

/*main.cpp*/ 
#include <iostream> 
#include "test.h" 
using namespace std; 

int main() 
{ 
test T; 
T.display(10); 
T.print(); 

system("pause"); 
return 0; 
} 

运行结果正常，下面来看看将内联函数放到.cpp中去：
/*test.h*/ 
#ifndef TEST_H 
#define TEST_H 

#include <iostream> 
using std::cout; 
using std::endl; 

class test 
{ 
public: 
test():x(10){} 
inline void print(); 
void display (int y); 
private: 
int x; 
}; 

#endif 

/*test.cpp*/ 
#include <iostream> 
#include "test.h" 
using std::cout; 
using std::endl; 

void test::print() 
{ 
cout << x << endl; 
} 

void test::display(int y) 
{ 
cout << x * y << endl; 
} 

测试函数和上面的main.cpp是一样的。这是出现了错误：

error LNK2019: 无法解析的外部符号 "public: void __thiscall test::print(void)"(?print@test@@QAEXXZ)，
该符号在函数 _main 中被引用。如果将测试函数改为：

int main() 
{ 
test T; 
T.display(10); 
//T.print(); 

system("pause"); 
return 0; 
} 
那么运行结果正常。从此可以得出结论：内联函数放在头文件或者.cpp中都是没有错的，
但如果需要在程序中访问它，那么就必须将其放在头文件中。

今日温习C   Primer的时分，看到了关于C  类的内联成员函数的放置，大概放在头文件中。那么这到底是为什么 呢？仅仅是一种代码标准疑问仍是有必要这样做呢？ 下面我就来讲讲我个人的了解吧。要完全了解这个疑问，首要就要了解下函数的声明和界说了。咱们晓得，函数能够 在多处声明，但只能在一个当地界说，否则就会呈现重界说。大多数函数默许是外部连接，而inline函数默许为内部链 接。也就是说inlin http://www.fp1111.info/linked/20130312.do e函数只能在本文件中运用，对其他文件是不行见的。通常咱们运用某个类的时分，都是在文件中加 上该类的头文件，以便咱们能够运用该类的接口。而咱们类的成员函数的完成都是放在相应的.cpp文件中的，而在.h 文件中声明。这样咱们便能够经过.h文件中的成员函数的声明找到其界说，继而运用成员函数了。但若是将inline函数 放在.cpp文件中，那么其只对.cpp文件有用，这样咱们就无法访问它了。所以咱们将其放在类的声明的头文件中，这 样经过包括该头文件来运用它。 下面写个实践的比如来阐明一下，我先把内联函数放到类声明的头文件中： /*test.h*/
#ifndef TEST_H
#define TEST_H

#include 
using std::cout;
using std::endl;

class test
{
public:
	test():x(10){}
	inline void print();
	void display (int y);
private:
	int x;
};

void test::print()
{
	cout << x << endl;
}

#endif /*test.cpp*/
#include 
#include "test.h"
using std::cout;
using std::endl;

void test::display(int y)
{
	cout << x * y << endl;
} /*main.cpp*/
#include 
#include "test.h"
using namespace std;

int main()
{
	test T;
	T.display(10);
	T.print();

	system("pause");
	return 0;
} 运转成果正常，下面来看看将内联函数放到.cpp中去： /*test.h*/
#ifndef TEST_H
#define TEST_H

#include 
using std::cout;
using std::endl;

class test
{
public:
	test():x(10){}
	inline void print();
	void display (int y);
private:
	int x;
};

#endif /*test.cpp*/
#include 
#include "test.h"
using std::cout;
using std::endl;

void test::print()
{
	cout << x << endl;
}

void test::display(int y)
{
	cout << x * y << endl;
} 测试函数和上面的main.cpp是相同的。这是呈现了过错： error LNK2019: 无法解析的外部符号 "public: void __thiscall test::print(void)" (?print@test@@QAEXXZ)，该符号在函 数 _main 中被引证。若是我将测试函数改为： int main()
{
	test T;
	T.display(10);
	//T.print();

	system("pause");
	return 0;
} 那么运转成果正常。从此能够得出结论：内联函数放在头文件或许.cpp中都是没有错的，但若是咱们需要在程序中访 问它，那么就有必要将其放在头文件中。 http://www.fpnanchang.com/linked/20130312.do 
转载于:https://www.cnblogs.com/fpqqchao/archive/2013/03/13/2957105.html

今天复习C++ Primer的时候，看到了关于C++类的内联成员函数的放置，应该放在头文件中。那么这到底是为什么
呢？仅仅是一种代码规范问题还是必须这样做呢？
下面我就来讲讲我自己的理解吧。要彻底理解这个问题，首先就要了解下函数的声明和定义了。我们知道，函数可以
在多处声明，但只能在一个地方定义，不然就会出现重定义。大部分函数默认是外部链接，而inline函数默认为内部链
接。也就是说inline函数只能在本文件中使用，对其他文件是不可见的。一般我们使用某个类的时候，都是在文件中加
上该类的头文件，以便我们可以使用该类的接口。而我们类的成员函数的实现都是放在相应的.cpp文件中的，而在.h
文件中声明。这样我们便可以通过.h文件中的成员函数的声明找到其定义，继而使用成员函数了。但如果将inline函数
放在.cpp文件中，那么其只对.cpp文件有效，这样我们就无法访问它了。所以我们将其放在类的声明的头文件中，这
样通过包含该头文件来使用它。
下面写个实际的例子来说明一下，我先把内联函数放到类声明的头文件中：
 


[cpp] view plaincopyprint?
 


/*test.h*/  
#ifndef TEST_H  
#define TEST_H  
  
#include <iostream>  
using std::cout;  
using std::endl;  
  
class test  
{  
public:  
    test():x(10){}  
    inline void print();  
    void display (int y);  
private:  
    int x;  
};  
  
void test::print()  
{  
    cout << x << endl;  
}  
  
#endif  

 


[cpp] view plaincopyprint?
 




/*test.cpp*/  
#include <iostream>  
#include "test.h"  
using std::cout;  
using std::endl;  
  
void test::display(int y)  
{  
    cout << x * y << endl;  
}  


 


[cpp] view plaincopyprint?
 




/*main.cpp*/  
#include <iostream>  
#include "test.h"  
using namespace std;  
  
int main()  
{  
    test T;  
    T.display(10);  
    T.print();  
  
    system("pause");  
    return 0;  
}  




运行结果正常，下面来看看将内联函数放到.cpp中去：
 
 


[cpp] view plaincopyprint?
 




/*test.h*/  
#ifndef TEST_H  
#define TEST_H  
  
#include <iostream>  
using std::cout;  
using std::endl;  
  
class test  
{  
public:  
    test():x(10){}  
    inline void print();  
    void display (int y);  
private:  
    int x;  
};  
  
#endif  


 


[cpp] view plaincopyprint?
 




/*test.cpp*/  
#include <iostream>  
#include "test.h"  
using std::cout;  
using std::endl;  
  
void test::print()  
{  
    cout << x << endl;  
}  
  
void test::display(int y)  
{  
    cout << x * y << endl;  
}  




测试函数和上面的main.cpp是一样的。这是出现了错误：
 
error LNK2019: 无法解析的外部符号 "public: void __thiscall test::print(void)" (?print@test@@QAEXXZ)，该符号在函
数 _main 中被引用。如果我将测试函数改为：
 


[cpp] view plaincopyprint?
 




int main()  
{  
    test T;  
    T.display(10);  
    //T.print();  
  
    system("pause");  
    return 0;  
}  




那么运行结果正常。从此可以得出结论：内联函数放在头文件或者.cpp中都是没有错的，但如果我们需要在程序中访
 
问它，那么就必须将其放在头文件中。
转载于:https://www.cnblogs.com/hwl1023/p/4921225.html

中二安卓班9月份考试 

一、  选择题（15*4=60分）                   总分120分 

1、  下列哪种成员修饰符的变量只能在本类中被访问（d） 

A   protected   B   public      C   default D   private 

2、  有一个类Bird，下面构造方法声明正确的是（b） 

A  void Bird(int x){}   B  Bird(int x){}   C      bird(int x){}    D    void bird(int x){} 

2、  下列关于方法的说法不正确的是（c） 

A、  Java中的构造方法名必须和类名相同 

B、  方法体是对方法的实现，包括变量声明和合法语句 

C、  如果一个类定义了构造方法，也可以用该类的默认构造方法 

D、  类的私有方法不能被其他类直接访问 

3、  关于内部类，下列说法不正确的是（a） 

A内部类不能有自己的成员方法和成员变                                         量 

B 内部类可用private或protected修饰符修饰 

C 内部类可以作为其他类的成员，而且可访问它所在的类的成员 

D 除static内部类外，不能在类里面声明static成员 

4、  定义外部类时不能用到的关键字是（c） 

A final     B  public   C  protected     D  abstract 

5、  下列程序的运行结果是（c） 

public class X5_1_2 extends x{ 

   int ab(){      static int  aa=10;   aa++;      System.out.println(aa);     }  

public static void main(String[] args) {        X5_1_2 x=new   X5_1_2();       x.ab();     }  } 

A    10     B    11     C 编译错误  D 运行成功，但不输出 

6、  下面关于接口的说法中不正确的是（c） 

A．  接口中所有的方法都是抽象的 

B．  接口中所有的方法都是public访问权限  

C．  子接口继承父接口所用的关键字是implements 

D．  接口是Java中的特殊类，包含常量和抽象方法 

7、  子类对象能否直接向其父类赋值？父类对象能否向其子类赋值？（b） 

A．能，能   B．能，不能      C．不能，能      D．不能，不能 

8、Java语言类间的继承关系是（a） 

A．单继承  B．多重继承   C．不能继承   D．不一定 

9、一个类实现接口的情况是（a） 

A．一次可以实现多个接口        B．一次只能实现一个接口 

C．不能实现接口            D．不一定 

10、关于异常的含义，下列描述中最正确的一个是（d） 

A．程序编译错误           B．程序语法错误  

C．程序自定义的异常事件    D．程序编译或运行时发生的异常事件 

11、运行下面程序时，会产生什么异常（c） 

public class X7_1_5 {  

  public static void main(String[] args) {   int[] z = {1,2,3,4};   int p = z[4];   int x = 0;   int y = 5/x;   } } 

A．ArithmeticException               B．NumberFormatException  

C．ArrayIndexOutOfBoundsException    D．IOException 

12、下列程序执行的结果是（b） 

public class X7_1_6 {  

   public static void main(String[] args) {    try{     return;    }    finally{     System.out.println(“Finally”);    }      }} 

A．程序正常运行，但不输出任何结果   B．程序正常运行，并输出Finally  

C．编译通过，但运行时出现异常 D．因为没有catch子句，因此不能通过编译 

13、下列代码中给出正确的在方法体内抛出异常的是（b） 

A．new throw Exception(” “);     B．throw new Exception(” “); 

C．throws IOException();     D．throws IOException; 

14、Java语言提供处理不同类型流的类所在的包是（d） 

A．java.sql  B．java.util     C．java.net   D．java.io 

15、HashMap实现了哪个接口（a） 

A  Map  B  Set  1       C  List     D TreeMap 

二、  填空题（10*2=20分） 

1、  Java语言为我们提供了 （try catch）  语句和（try catch finnaly）语句捕捉并处理异常。 

2、  抛出异常分为 由系统自动抛出异常 、 通过（throws）抛出异常  以及 通过（throw）抛出异常  三种情况。 

3、   （Object）类    是所有类的直接或间接父类，它在（java.lang）  包中。 

4、  如果子类自己没有构造方法，此时它将调用父类的（默认构造方法）作为自己的构造方法；如果子类自己定义了构造方法，则在创建对象时，它先执行（父类）的构造方法，然后再执行自己的（构造方法）。 

5、  对于父类的含参数构造方法，子类可以通过在自己的构造方法中使用 （super）方法来调用它，但这个调用语句必须是子类构造方法的 （第一条）可执行语句。 

6、  Java中提供两种多态机制，  （重载）  与 （重写）。 

7、  Java提供了4种访问权限来实现封装机制即 （public）、 （protected）  、 （private）和 （default）。 

8、   （interface） 是声明接口的关键字，可以把它看成一个特殊类。接口中的数据成员默认的修饰符是（public static final），接口中的成员方法默认的修饰符是（public abstract）。 

9、  如果实现某接口的类不是abstract的抽象类，则在类的定义部分必须 （实现）该接口的所有抽象方法。 

10、 抽象类不能   （实例化）  对象，该工作由抽象类派生的非抽象子类来实现。 

三、  编程题：(5*8=40分) 

1．  编写一个实现方法重载的程序。 

2．  编写一个实现方法重写的程序。 

3．  编写一个人类Person，其中包含姓名、性别和年龄的属性，包含构造方法以及显示姓名、性别和年龄的方法。再编写一个学生类Student，它继承Person类，其中包含学号属性，包含构造方法以及显示学号的方法。最后编写一个主类X5_3_5，包含main()方法，在main()方法中定义两个学生s1和s2并给他们赋值，最后显示他们的学号、姓名、性别以及年龄。 

4．  首先让计算机随机产生出10个两位正整数，然后按照从小到大的次序显示出来 

5．  package com.zhiyuan.frank; 

6． 

7．  import java.util.Arrays; 

8． 

9．  public class Tes { 

10．  

11．     public static void main(String[] args) { 

12．         //定义一个整形数组用来装生成的随机数 

13．         int ar[]=new int[10]; 

14．         //循环生成随机数，并把每次生成的随机数通过数组下标放到数组里面 

15．         for(int x=0;x<10;x++){ 

16．             int li=(int) Math.random()*100; 

17．             int can=Math.max(10, li); 

18．             ar[x]=can; 

19．         } 

20．         //将数组进行排序 

21．         Arrays.sort(ar); 

22．         //遍历数组，打印出结果 

23．         for (int i = 0; i < ar.length; i++) { 

24．             System.out.println(ar[i]); 

25．         } 

26．     } 

27． }

28． 编写一个程序实现将字符串“今日的懒惰成为明日打脸的巴掌”写入到桌面的test.txt文件中，然后从该文件中将内容读取出来输出到控制台。