编译的底层是什么

❶ 软件编写的底层是C++与应该用层用java是什么意思啊求解释，什么叫做底层和应用层

底层就是后台运行的部分
应用层就是前台界面，我们能看到，能操作的部分。

比如一个人员管理系统：
底层访问数据库啊，逻辑判断啊，都用C++完成，这样速度快
应用层呢，用Java实现，这样控件丰富，界面漂亮。

❷ 编译和操作系统哪个更底层

操作系统就是C语言编译出来的，你问的这两个东西其实是一个东西。

❸ 请问编程中的 上层 和 底层 是什么意思 比如有人说 ＂游戏用JAVA或c#做上层，用汇编或c/

上层（或者是表层）、中间层和底层没有严格意义上的定义，在不同的项目中需要结合具体需求来具体分析。

一般来说，表层就是指展现给用户看的部分；而底层就是系统的最核心的部分。一般我们认为，越接接硬件的编程就越底层。

比如，一个在线通讯软件（QQ这种），表层就是窗口啊、菜单啊、按钮啊这些玩意儿；中间层是业务逻辑部分，就是你点击这些按钮会产生相应的什么事件，进行了什么操作；底层就是Socket网络通信了。当然，我这里这三层是大致划分的，实际开发中比这个要更具体详细。

再比如，拿题主说的游戏举例子，表层就是各种游戏的界面了；底层就是游戏引擎了。底层干嘛？接收你的鼠标键盘响应信号、操作显卡在显示器指定位置生成各种二维的三维的图像、控制声卡输出音频等等等等。

至于编程语言问题，这就牵扯到低级语言和高级语言的问题了。一般来讲低级语言和高级语言区别在于：

• 高级语言：实现效率高，执行效率低，对硬件的可控性弱，目标代码大，可维护性好，可移植性好。

• 低级语言：实现效率低，执行效率高，对硬件的可控性强，目标代码小，可维护性差，可移植性差。

越低级的语言，形式上越接近机器指令（汇编语言就是与机器指令一一对应的）。而越高级的语言，一条语句对应的指令数越多，其中原因就是高级语言对底层操作进行了抽象和封装，使编写程序的过程更符合人类的思维习惯，并且极大了简化了人力劳动。也就是说你用高级语言写一句，会被转换成许多底层操作，大部分的工作交给了负责转换的机器（即编译器），从而人力得到了解放。因为机器就是用来为人类提供便利的，所以说高级语言的出现是计算机发展的必然结果。（参考：http://blog.csdn.net/guoxiaoqian8028/article/details/9103151）这就产生了执行效率的问题。

所以说用 C/C++ 这类语言更适合写游戏引擎。游戏嘛，必定是要求响应速度极高的，总不能按完键盘了等100毫秒才响应，生成个三维地图电脑卡半天。但一般不会游戏的所有部分都用 C/C++ 来完成，为什么？上面说了，可维护性差、可移植性差。这时候就需要用面向对象这种“高级语言”出马了。

至于题主提到的“不同语言之间的互通”，建议题主理解一下“接口”（不是面向对象里的“接口类型”）的概念。

泛泛而谈，希望对题主有所帮助。

❹ C/C++最底层是怎么实现的

许多同学可能在学习C++的时候，都会感到一定的困惑，继承到底是怎样分配空间的，多态到底是如何完成的，许许多多的问题，必须挖掘到C++底层处理机制，才能搞明白。有许多C程序员也并不认同C++，他们认为C++庞大又迟缓，其更重要的原因是，他们认为“C++是在你的背后做事情”。的确，C++编译器背着程序员做了太多的事情，所以让很多不了解其底层机制的人感到困惑。想成为一个优秀的程序员，那么这样的困惑就不应该存在，只有了解了底层实现模型，才能写出效率较高的代码，自信心也比较高。
我们先从一个简单但有趣的例子谈起。有如下的4个类：
class X {};
class Y : public virtual X {};
class Z : public virtual X {};
class A : public Y, public Z {};
上面的4个类中，没有任何一个类里含明显的数据，之间只是表示了继承关系，那么如果我们用sizeof 来测量它们的大小，将会得到什么结果呢？
你可能会认为，既然没有任何数据和方法，大小当然为0，而结果肯定会出乎你的意料，即使是class X 的大小也不为0。
在不同的编译器上，将会得到不同的结果，而在我们现在最常用的VC++编译器上，将得到如下的结果：
sizeof X 的结果是 1 。
sizeof Y 的结果是 4 。
sizeof Z 的结果是 4 。
sizeof A 的结果是 8 。
惊讶吗？那么为什么会得到这样的结果？让我们一个一个来分析。
对于一个空的class，事实上并不是空的，它有一个隐晦的1 byte ，那是被编译器安插进去的一个char 。这使得这个class 的两个对象得以在内存中配置独一无二的地址，这就是为什么 sizeof X 的结果是 1。
那么Y和Z呢，怎么会占用 4 byte ？其实它们的大小受到三个因素的影响：
1. 语言本身所造成的额外负担：当语言支持多态时，就会导致一些额外负担。在派生类中，这个额外负担表现在一个指针上，它是用来指向一个被称作“虚函数列表”的表格。而在VC++编译器上，指针的大小正好是 4 byte 。
2. 编译器对于特殊情况所提供的优化处理：在class Y 和 class Z 中，也将带上它们因为继承class X 而带来的 1 byte ，传统上它被放在派生类的固定部分的尾端。而某些编译器（正如我们现在所讨论的VC++编译器）会对空的基类提供特殊的处理，在这个策略下，一个空的基类被视为派生类对象最开头的一部分，也就是说它并没有花费任何额外空间（因为既然有了成员，就不需要原本为了空类而安插一个char了），这样也就节省了这 1 byte 的空间。事实上，如果某个编译器没有提供这种优化处理，你将发现class Y 和 class Z 的大小将是8 byte ，而不仅仅是5 byte 了，原因正如下面第3点所讲。
3. “对齐”（Alignment）机制：在大多数机器上，群聚的结构体大小都会受到alignment的限制，使它们能够更有效率地在内存中被存取。Alignment 就是将数值调整到某数的整数倍。在32位计算机上，通常alignment 为 4 byte（32位），以使总线达到最大的“吞吐量”，在这种情况下，如上面所说，如果 class Y 和class Z 的大小为 5 byte ，那么它们必须填补 3 byte ，最终得到的结果将是 8 byte 。是不是开始感谢VC++编译器幸好有这样的优化机制，使得我们节约了不少内存空间。
最后，我们再来看看 class A ，它的大小为什么是 8 byte ？显而易见，它继承了class Y 和class Z ，那么它的大小直接就把 class Y 和class Z 的大小加起来就够了。真有这么简单吗？实际上这只是一个巧合而已，这是因为之前编译器的优化机制掩盖这里的一些事实。对于没有优化的 class Y 和class Z 来说，他们的大小都是8 byte ，那么继承了它们两个的 class A 将是多大呢？16 byte？如果你有这样的编译器试一下的话，你会发现答案是12 byte 。怎么会是12 byte 呢？记住，一个虚拟继承的基类只会在派生类中存在一份实体，不管它在 class 继承体系中出现了多少次！class A的大小由下面几部分决定：

l 被大家共享的唯一一个 class X的实体，大小为1 byte。
l 基类class Y 的大小，减去因虚拟继承的基类class X而配置的大小，也就是4 byte 。基类class Z的算法相同，它们加起来就是8 byte 。
l class A自己的大小，0 byte 。
l class A 的alignment的大小（如果有的话）。前述三项的总和是9 byte ，那么调整到4 byte的整数倍，也就是12 byte 。
我们前面讨论的VC++编译器得出的结果之所以是8 byte ，是因为 class X 实体的那1 byte被拿掉了，于是额外的3 byte也同样不必了，因此就直接把class Y 和class Z的大小加起来，得到8 byte 。
这个例子看懂了吗？是不是对C++的底层机制开始感兴趣了？那么我们再来举一个同样有趣的例子。
有这样一个类：
class A {
private:
int a;
char b;
char c;
char d;
};
它的大小是多少呢？
如果你有记得我之前提到的alignment机制的话，你应该会猜到它的大小是8 byte 。的确如此，int a占用4 byte ，char b , char c 和char d各占1 byte ，加起来是7 byte ，再加上alignment额外带来的1 byte ，总共是8 byte 。
瞧，就是这么简单，那么现在我们把里面的成员变量换换位置，如下：
class A {
private:
char d;
int a;
char b;
char c;
};
我们将char d拿到第一个位子，放在int a之前。那么现在你能告诉我class A的大小是多少呢？你肯定不会再猜8 byte了，因为你会觉得这与上面似乎有些不同，但你不能肯定到底是多大。不敢确定的时候就去试试吧，原来是12 byte ，这又是怎么回事呢？同样的类，只是改变了成员变量的位子，怎么就会多出4 byte的存储空间？其实这一切又是由变量的存储规则造成的。对于一个类来说，它里面的成员变量（这里单指非静态的成员变量）是按声明的顺序存储在内存空间中的。在第一种的情况中，它们紧紧的排列在一起，除了由于alignment所浪费的1 byte空间外，它们几乎用了最小的存储空间；而在第二种情况中，它们则不是排列得那么紧密了，错误就在于char d ，它一个人就占用了4 byte 。为什么它会占用4 byte呢，其实责任也不全在它，后面的int a也有不可推卸的责任。Int 型数据在VC++编译器中正好是占用4 byte的，等于一个alignment量，而这4 byte一定是密不可分的。当char d占用了1 byte后，其后空出了3 byte（对于一个alignment量来说），而一个int型数据不能被拆成3 byte +1byte来存储，那样编译器将无法识别，因此int a只有向后推到下一个alignment的开始，这样char d就独占了4 byte ，中间有3 byte浪费掉了。而后面的char b和char c依旧紧密排列，最后又由于alignment调整2 byte ，整个类的大小就变为了12 byte 。
看了这个例子，是不是该反省以前随意定义成员变量了？如果你要定义一个含3个int型数据和4个char型数据的类，本来最优化的方法只需要16 byte ，而你却随意的定义成如下的样子：
class F{
private:
char c1;
int i1;
char c2;
int i2;
char c3;
int i3;
char c4;
};
看看结果是什么，这个类竟然要占据28 byte的空间，比刚才整整大了12 byte！
再来看看继承的时候，成员变量是怎样存放的。我们将第2个例子中的class A 改成三层的继承模式，或许我们在做项目中，真的会遇到这样的情况。
class A1{
private:
int a;
char b;
};
class A2: public A1{
private:
char c;
};
class A3:public A2{
private:
char d;
};
现在我们来预测一下class A3 的大小，是8 byte吗？不，结果竟是16 byte ，竟然整整多了1倍。这是为什么呢？按照成员变量的排列顺序，int a,char b,char c,char d应该紧密的排列在一起，8 byte没错。但事实并非如此，这些都是因为继承而造成的。知道“在继承关系中，基类子对象在派生类中会保持原样性”吗？或许这样专业的一句话，你并不能明白是什么意思，那么听我下面的分析。在为派生类分配内存空间的时候，都是先为基类分配一块内存空间，而所谓的“原样性”是指基类原本在内存空间中是什么样子，那么它在派生类里分配的时候就是什么样子。拿这个例子来说，class A1占据了8 byte的空间，其中int a占4 byte ，char b占1 byte ，因alignment而填补3 byte 。对于class A1来说，占据8 byte空间没什么好抱怨的，但是class A2呢？轻率的程序员会认为，class A2只在class A1的基础上增加了唯一一个char c ，那么它应该会和char b绑在一起，占用原本用来填补空间的1 byte ，于是class A2的大小是8 byte，其中2 byte用于填补空间。然而事实上，char c是被放在填补空间所用的3 byte之后，因为在class A2中分配的class A1应该完全保持原样，于是class A2的大小变成12 byte ，而不是8 byte了，其中有6 byte浪费在填补空间上。相同的道理使得class A3 的大小是16 byte ，其中9 byte用于填补空间。
那么也许你会问，既然“原样性”会造成这样多的空间浪费，那么编译器为什么还要这样做呢？其实这样做是有它的必要的。我们考虑下面这种情况：
A1* pA1=new A1();
A1* pA2=new A2();
*pA1=*pA2;
我们定义了两个A1型指针，一个指向A1对象，一个指向A2对象。现在我们执行一个默认的复制操作（复制一个个的成员变量），那么这样一个操作应该是把pA2所指的对象的A1那部分完全复制到pA1所指的对象里。假设编译器不遵循“原样性”，而是将派生类的成员和基类的成员捆绑在一起存放，去填补空间，那么这样的操作变会产生问题了。A1和A2都占8 byte ，pA2会将其所指的8 byte空间里的内容全部复制给pA1所指的对象，那么pA1所指的对象本来只有2个数据，3 byte的填补空间，而复制后却变成了3个数据，2 byte的填补空间了，对于char c ，我们并不想把它复制过来的。这样完全破坏了原语意，而这样引起的bug几乎是无法察觉的。

❺ 计算机系统层次结构中最底层的是什么

计算机系统层次结构中最底层的是机器语言层，也有说是计算机硬件系统、机器硬件。计算机系统层次结构，指的是计算机系统由硬件和软件两大部分所构成，而如果按功能再细分，可分为7层。其中最底层的是硬联逻辑级。第零级是硬联逻辑级，这是计算机的内核，由门，触发器等逻辑电路组成。

计算机系统是由硬件和软件组成的层次式结构，硬件系统是计算机层次结构的最内层，使用计算机系统的用户是该层次结构中的最外层，用户与硬件系统之间的软件系统包括系统软件，支援软件和应用软件三部分 。

把计算机系统按功能分为多级层次结构，就是有利于正确理解计算机系统的工作过程，明确软件，硬件在计算机系统中的地位和作用。

(5)编译的底层是什么扩展阅读：

计算机按功能细分为7层，从第0层到第6层分别是：

硬联逻辑级

第零级是硬联逻辑级，这是计算机的内核，由门，触发器等逻辑电路组成。

微程序级

第一级是微程序级。这级的机器语言是微指令集，程序员用微指令编写的微程序，一般是直接由硬件执行的。

传统机器级

第二级是传统机器级，这级的机器语言是该机的指令集，程序员用机器指令编写的程序可以由微程序进行解释。

操作系统级

第三级是操作系统级，从操作系统的基本功能来看，一方面它要直接管理传统机器中的软硬件资源，另一方面它又是传统机器的延伸。

汇编语言级

第四级是汇编语言级，这级的机器语言是汇编语言，完成汇编语言翻译的程序叫做汇编程序。

高级语言级

第五级是高级语言级，这级的机器语言就是各种高级语言，通常用编译程序来完成高级语言翻译的工作。

应用语言级

第六级是应用语言级，这一级是为了使计算机满足某种用途而专门设计的，因此这一级语言就是各种面向问题的应用语言。

❻ 请教javascript、Java、C++、C的底层编程语言分别是什么

javascript是脚本语言,在客户端运行,有个解释器,wscript,应该是microsoft vc++写的.至于VC版本是多少应该是看你的计算机系统.java底层是C语言C的底层是汇编语言.其实都是由汇编语言写的底层,然后逐层往上面翻译。

❼ Java的底层是用什么语言写的

JVM 的话是 C++ 实现的。而c++则需要考虑效率，任何在windows下运行的程序,底层都是C/C++或者ASM，这是硬件指令系统决定的。
Java 类库是 Java 实现的。java主要面向于实现。

❽ 什么叫底层代码

底层代码是指被封装好的代码，底层代码写的就是比较原始，比较基础的代码。底层代码编写是非常接近机器的编程，使用底层开发语言（如C或汇编）。这与使用高级语言（例如Python，Java）的程序员进行编程不同。

对于java来说，底层代码一般是指框架的实现代码，这些代码一般都是一些常用代码或比较接近于原始的代码，这些代码封装好，可以方便复用和调用。而对一些操作系统来说，底层代码可能就是c或者汇编，写底层代码就是做底层开发。比如java的Map类，底层代码实现：

(8)编译的底层是什么扩展阅读

编写底层代码一般要比较深厚的功底，对程序设计，代码涉及的各个方面，性能，耦合度，复用性都要很深的掌握和考虑，熟练掌握设计模式,良好的编程习惯，代码优雅，数据结构，精通各种算法。

很多java框架被淘汰，除了本身有致命的bug外，还有就是有性能更好，使用更方便的框架出现，而这些都是靠底层代码实现来决定的。

❾ javascript、Java、C++、C的底层编程语言分别是什么

javascript是脚本语言,在客户端运行,有个解释器,wscript,应该是microsoft vc++写的.至于VC版本是多少应该是看你的计算机系统.java底层是C语言C的底层是汇编语言.其实都是由汇编语言写的底层,然后逐层往上面翻译。