精华内容
下载资源
问答
  • 今天复习C++ Primer的时候,看到了关于C++的内联成员函数的放置,应该放在头文件。...在多处声明,但只能在一个地方定义,不然就会出现重定义。大部分函数默认是外部链接,而inline函数默认为内部链 接。也就是说in
       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中都是没有错的,

    但如果需要在程序中访问它,那么就必须将其放在头文件中。

    展开全文
  • 我们知道,函数可以在多处声明,但只能在一个地方定义,不然会出现重定义。大部分函数默认是外部链接,而inline函数默认为内部链接。也是说inline函数只能在本文件使用,对其他文件是不可见的。一般我们使用某个...
  • 今日温习C Primer的时分,看到了关于C 的内联成员函数的...咱们晓得,函数能够 在多处声明,但只能在一个当地界说,否则就会呈现重界说。大多数函数默许是外部连接,而inline函数默许为内部链 接。也就是说inlin...
    今日温习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函数默认为内部链 接。也就是说in...

    今天复习C++ Primer的时候,看到了关于C++类的内联成员函数的放置,应该放在头文件中。那么这到底是为什么

    呢?仅仅是一种代码规范问题还是必须这样做呢?

    下面我就来讲讲我自己的理解吧。要彻底理解这个问题,首先就要了解下函数的声明和定义了。我们知道,函数可以

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

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

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

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

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

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

    下面写个实际的例子来说明一下,我先把内联函数放到类声明的头文件中:

     

    1. /*test.h*/  
    2. #ifndef TEST_H  
    3. #define TEST_H  
    4.   
    5. #include <iostream>  
    6. using std::cout;  
    7. using std::endl;  
    8.   
    9. class test  
    10. {  
    11. public:  
    12.     test():x(10){}  
    13.     inline void print();  
    14.     void display (int y);  
    15. private:  
    16.     int x;  
    17. };  
    18.   
    19. void test::print()  
    20. {  
    21.     cout << x << endl;  
    22. }  
    23.   
    24. #endif  

     

    1. /*test.cpp*/  
    2. #include <iostream>  
    3. #include "test.h"  
    4. using std::cout;  
    5. using std::endl;  
    6.   
    7. void test::display(int y)  
    8. {  
    9.     cout << x * y << endl;  
    10. }  

     

    1. /*main.cpp*/  
    2. #include <iostream>  
    3. #include "test.h"  
    4. using namespace std;  
    5.   
    6. int main()  
    7. {  
    8.     test T;  
    9.     T.display(10);  
    10.     T.print();  
    11.   
    12.     system("pause");  
    13.     return 0;  
    14. }  


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

     

     

    1. /*test.h*/  
    2. #ifndef TEST_H  
    3. #define TEST_H  
    4.   
    5. #include <iostream>  
    6. using std::cout;  
    7. using std::endl;  
    8.   
    9. class test  
    10. {  
    11. public:  
    12.     test():x(10){}  
    13.     inline void print();  
    14.     void display (int y);  
    15. private:  
    16.     int x;  
    17. };  
    18.   
    19. #endif  

     

    1. /*test.cpp*/  
    2. #include <iostream>  
    3. #include "test.h"  
    4. using std::cout;  
    5. using std::endl;  
    6.   
    7. void test::print()  
    8. {  
    9.     cout << x << endl;  
    10. }  
    11.   
    12. void test::display(int y)  
    13. {  
    14.     cout << x * y << endl;  
    15. }  


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

     

    error LNK2019: 无法解析的外部符号 "public: void __thiscall test::print(void)" (?print@test@@QAEXXZ),该符号在函

    数 _main 中被引用。如果我将测试函数改为:

     

    1. int main()  
    2. {  
    3.     test T;  
    4.     T.display(10);  
    5.     //T.print();  
    6.   
    7.     system("pause");  
    8.     return 0;  
    9. }  


    那么运行结果正常。从此可以得出结论:内联函数放在头文件或者.cpp中都是没有错的,但如果我们需要在程序中访

     

    问它,那么就必须将其放在头文件中。

    转载于:https://www.cnblogs.com/hwl1023/p/4921225.html

    展开全文
  • 初识JAVA,检测考试题

    千次阅读 2018-03-08 14:42:54
    中二安卓班9月份考试 ...1、 下列成员修饰符的变量只能在类中被访问(d) A protected B public C default D private 2、 有一个类Bird,下面构造方法声明正确的是(b) A void Bird(int x){} B ...

    中二安卓班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文件中,然后从该文件中将内容读取出来输出到控制台。

    展开全文
  • 熟悉DOS的读者可能就知道:DOS下面的图形操作很方便,进入图形模式,整个屏幕就是你的了,你希望在哪画个点,那个地方就会出现一个点,红的、或者黄的,随你的便。你也可以花点时间画个按钮,画个你自己的菜单,等等...
  • 请问,应该选择下面哪一个字符串?( B )  A. “Server=AllWin;Data Source=PubBase;Initial Catalog=Test;Integrated Security=SSPI”  B. “Server= AllWin;Data Source=PubBase;Database=Test;Integrated ...
  • c#学习笔记.txt

    热门讨论 2008-12-15 14:01:21
    在类中,必须初始化实例对象. 使用 new 运算符创建结构对象时,将创建该结构对象,并且调用适当的构造函数。与类不同的是,结构的实例化可以不使用 new 运算符。如果不使用 new,那么在初始化所有字段之前,字段将...
  • A) 一个的声明里声明的,也叫做内部或嵌套,内部可以作为外包一个成员使用,可以访问外包的所有成员,包括私有成员。 B) 内部的访问权限可以被定义为public、protected、private和default。但是...
  • 类中的大多数数据,只能用本类的方法进行处理。类通过一个简单的外部接口,与外界发生关系,对象与对象之间通过消息进行通讯。这样,程序模块间的关系更为简单,程序模块的独立性、数据的安全性就有了良好的保障。...
  • 因此新建一个测试代码<code>test/index.js</code></p> <pre><code> js 'use strict'; require('should'); const mylib = require('../index'); describe('My First Test', ...
  • JAVA面试题最全集

    2010-03-13 13:09:10
    给定一个C语言函数,要求实现java类中进行调用。 45.如何获得数组的长度? 46.访问修饰符“public/private/protected/缺省的修饰符”的使用 47.用关键字final修饰一个类或者方法时,有何意义? 48.掌握类和...
  • C#微软培训教材(高清PDF)

    千次下载 热门讨论 2009-07-30 08:51:17
    第三章 编写第一个应用程序 .20 3.1 Welcome 程序 .20 3.2 代 码 分 析 .20 3.3 运 行 程 序 .23 .4 添 加 注 释 .25 3.5 小 结 .27 第二部分 C#程序设计基础.28 第四章 数 据 型 .28 4.1 值 型...
  • 知道其行为的其它类可以在类中实现这些方法。  接口(interface)是抽象类的变体。在接口中,所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的,没有一个有程序体。接口只可以...
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题126 一个类可以访问另一个类的私有成员吗 137 11.4 函数重载 138 面试题127 函数重载与作用域 138 面试题128 如何进行函数重载的匹配 139 面试题129 函数重载时如何实现实参的类型转换 140 第12章 模板与STL...
  • C#微软培训资料

    2014-01-22 14:10:17
    第三章 编写第一个应用程序 .20 3.1 Welcome 程序 .20 3.2 代 码 分 析 .20 3.3 运 行 程 序 .23 .4 添 加 注 释 .25 3.5 小 结 .27 第二部分 C#程序设计基础.28 第四章 数 据 型 .28 4.1 值 型...
  • java 面试题 总结

    2009-09-16 08:45:34
    知道其行为的其它类可以在类中实现这些方法。 接口(interface)是抽象类的变体。在接口中,所有方法都是抽象的。多继承性可通过实现这样的接口而获得。接口中的所有方法都是抽象的,没有一个有程序体。接口只可以...
  • 是哪个private修饰的方法、字段、构造方法需要执行,就需要用这个对象破坏哪一个的封装 例如: //获取cn.itsource.reflect.User字节码文件 Class<?> clazz = Class.forName(...
  • 这一讲,我们主要是了解一下 Linux 的概况,以及对 Linux 有一个初步的感性认识。 一.什么是Linux? Linux 是一个以 Intel 系列 CPU(CYRIX,AMD 的 CPU也可以)为硬件平台,完全免费的 UNIX 兼容系统,完全...
  • 抽象类中是否可以有静态的main方法? 15 21、写clone()方法时,通常都有行代码,是什么? 15 22、面向对象的特征有哪些方面 15 23、java中实现多态的机制是什么? 17 24、abstract class和interface有什么区别? ...
  • c++ 面试题 总结

    2009-09-16 08:44:40
    段式管理:把主存分为一段一段的,每一段的空间又要比一页一页的空间小很多,这种方法空间利用率上又比页式管理高很多,但是也有另外一个缺点。一个程序片断可能会被分为几十段,这样很多时间就会被浪费计算每一...
  • 8.5.4 例2:从下一行返回一个值 204 8.6 First_value和Last_value 205 8.6.1 例子:使用First_value来计算最大值 206 8.6.2 例子:使用Last_value来计算最小值 207 8.7 其他分析函数 207 8.7.1 Nth_value(11...
  • 8.5.4 例2:从下一行返回一个值 204 8.6 First_value和Last_value 205 8.6.1 例子:使用First_value来计算最大值 206 8.6.2 例子:使用Last_value来计算最小值 207 8.7 其他分析函数 207 8.7.1 Nth_value(11...
  • 3. 同一个类中定义多个参数列表不同的同名方法,叫做方法的重载。( ) 4. 一个类的定义包括定义类头和定义类体两个部分。( ) 5.一个程序里可以有多个父类,也可以有多个主类。( ) 6. 一个子类可以重新定义从父类那里...
  • 1)函数体,一个被声明为静态的变量这一函数被调用过程维持其值不变。 2) 模块内(但函数体外),一个被声明为静态的变量可以被模块内所用函数访问,但不能被模块外其它函数访问。它是一个本地的全局变量...
  • 新版Android开发教程.rar

    千次下载 热门讨论 2010-12-14 15:49:11
    也有分析认为,谷歌并不想做一个简单的手机终端制造商或者软件平台开发商,而意一统传统互联网和 移 动互联网。----------------------------------- Android 编程基础 4 Android Android Android Android 手机新...
  • B) 图形工具能够极好地概括描述一个系统的信息,比文字叙述能够更好地表达重 要的细节 C) 图形能够更加直观地描述目标系统,便于用户理解和交流,有利于开发者与用 户之间达成一致的需求 D) 图形比文字描述简单、...

空空如也

空空如也

1 2
收藏数 32
精华内容 12
关键字:

在类中下面哪一个成员只能在