小编Fro*_*raw的帖子

好的,所以我一直在读一本关于C#和.NET的书,同时学习DateTime结构和以下代码:

DateTime dt = new DateTime(2015, 10, 17);

我问自己"为什么我不必通过写作在顶部引用它using System.DateTime"？

因此,我意识到,由于日期时间是一个结构,而"使用"关键字用于引用类型(类型是一个通用术语,是指从集合{类,接口,结构,枚举,委托}为成员)中所定义特定命名空间(在本例中,DateTime是System Namespace中的类型结构).

但是我注意到在我文件的顶部,找到了以下using指令(当我创建C#控制台应用程序时它们会自动放在那里):

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

我想知道为什么后面的using指令using System是必要的,什么时候它们都不在System命名空间下,因此它们应该已被引用？

所以我猜它是因为它下面声明的所有都是名称空间,而不是来自集合{class,interface,structure,enumeration,delegate}的类型.然而这是错误的,称他们为"(或属于)的命名系统命名空间,"如果是这样,那是什么,你必须明确地引用命名空间,而不是他们的下隐含地包括命名空间的原因using System？

我希望我的问题很明确,但如果没有,请告诉我,以便我可以编辑.

我有可能是一个愚蠢的问题,但我只是不理解我的书对它的解释.

它说"当编译器看到模板的定义时,它不会生成代码.它只在我们实例化模板的特定实例时生成代码.事实上代码只在我们使用模板时生成(而不是在我们使用模板时生成定义它)影响我们组织源代码的方式以及何时检测到错误...要生成实例化,编译器需要具有定义函数模板或类模板成员函数的代码.因此,与非模板代码不同,模板的标题通常包括定义和声明."

"生成代码"究竟是什么意思？我想我从来没有真正考虑过编译器发生了什么,并且对它没有太多了解,所以当你编译模板函数或类与非模板函数或类相比时,我不理解它们有什么不同

所以我一直试图尽可能地理解Big O符号,但仍有一些我很困惑的事情.所以我一直在读,如果有东西是O(n),它通常指的是算法的最坏情况,但它不一定要参考最坏的情况,这就是为什么我们可以说最好的例如,插入排序的大小是O(n).但是,我无法理解这意味着什么.我知道如果最坏情况是O(n ^ 2),这意味着在最坏情况下表示算法的函数增长不快于n ^ 2(存在上限).但如果你有O(n)作为最好的情况,我应该怎么读呢？在最好的情况下,算法增长不比n快？我的图片是以n为上限的图形,如

如果算法的最佳情况是O(n),那么n是算法运算在最佳情况下增长的速度的上限,因此它们不能比n增长得快......但这并不意味着它们可以像O(log n)或O(1)那样快速增长,因为它们低于上限？这没有意义,因为O(log n)或O(1)是比O(n)更好的场景,所以O(n)不是最好的情况吗？我很失落哈哈

我只是......我不完全确定我理解封装.也许这可能与我仍然在课堂上学习编程而没有制作任何像其他人使用的.REAL世界程序这一事实有关,但我只是不明白它想要完成什么.我理解它限制访问某些类的成员和函数.但是喜欢......从谁那里限制它？我已经看到了几个他们有私有数据成员的例子,但他们有公共的get或set方法,无论如何都可以操作数据成员.那么有什么限制或隐藏的东西呢？

我的书说如下:

"封装提供了两个重要优势:

1. 用户代码不会无意中破坏封装对象的状态.
2. 封装类的实现可以随着时间的推移而改变,而无需更改用户级代码."

我想我对他们使用的单词感到困惑.用户代码如何可能破坏对象的状态,或者有人能给我一个例子吗？

我知道我的问题到处都是,但在考虑封装时我的想法也是如此,所以我很难将所有关于它的想法都包含在内(..lol)

我有一个Customers表和一个订单表.并非所有客户都下订单,因此并非所有客户ID都在订单表中.我希望我的结果只显示来自customer表的未下订单的值,因此orderID列应显示为null.以下代码有效:

SELECT c.CustomerID, c.CustomerName, o.OrderID
  FROM Customers c
    LEFT OUTER JOIN Orders o
ON c.CustomerID = o.CustomerID WHERE o.OrderID IS NULL

但我最初尝试的那个不是:

SELECT c.CustomerID, c.CustomerName, o.OrderID
  FROM Customers c
    LEFT OUTER JOIN Orders o
ON c.CustomerID = o.CustomerID AND o.OrderID IS NULL

这一个显示了customers表上的所有值,但是它们的orderID都是null

我不认为我真的理解这种差异,因为我觉得他们都回归同样的事情是有意义的.

我一直看到它被定义为

完全二叉树是一种二叉树，其中每一层（可能除了最后一层）都被完全填充，并且所有节点都尽可能地向左。

但是..我不知道“所有节点都尽可能远离”是什么意思。这就是我的问题。我无法进一步扩展它，因为我不知道“所有节点都尽可能远离”是什么意思。比如..与什么相比尽可能地靠左？我不明白

这是一个作业问题，但作业已经到期，我们已经得到了答案，我只是不知道他们实际上是如何得出这些答案的。

它与缓存有关，我只是混淆了很多概念。

这是问题：

对于具有 32 位地址的直接映射缓存设计，地址的以下位用于访问缓存。

根据我的理解，索引位确定内存中的特定位置映射到缓存中的哪个块。地址的最低 log(base2) 位决定了缓存块，这里有 5 个索引位，所以我知道缓存中总共有 2^5 个块，即 32 个。

缓存块大小是多少（以字为单位）？

根据给我们的答案，缓存块大小是 8。根据我们的 TA 给我们的一些注释，块大小是 2^(偏移位的#)，在本例中为 5。但是，给我答案 32，所以我不知道 8 来自哪里。此外，本书中没有任何地方定义术语“偏移位”，所以有人可以准确地告诉我这意味着什么吗？

**我在这里的想法是，由于同一个内存地址永远不会被引用两次，所以不应该有命中，因为缓存永远不会拥有它在缓存中查找的数据。然而，根据答案，命中率应该是 0.25，所以我再一次想我不明白发生了什么。最后，对于最后一个问题，答案如下：

<000001, 0001, 内存[1024]>

<000001, 0011, 内存[16]>

<001011, 0000, 内存[176]>

<001000, 0010, 内存[2176]>

<001110, 0000, 内存[224]>

<001010, 0000, 内存[160]>

其中包含一些内存地址（176、2176），这些地址甚至不在最初的问题中，所以到目前为止我完全失去了一切。有人可以帮我解决其中一些问题吗？**

我真的很困惑这里到底发生了什么......

我有这个功能

void addToFront(int data)  
{
  Node* tmp = new Node();
  tmp -> data = data;
  tmp -> next = head;
  head = tmp;
}

因此,当我们执行该行时tmp-> next = head,我们使tmp指针指向head指向的内容(列表的当前第一个元素)？因为这就是它的感觉,但是这不仅仅是指向它head吗？然后当我们这样做时head = tmp,我们正在指向我们创建的新节点,对吗？

在我的C++书中,有一个两页的C-Style Character Strings(这几乎看起来毫无意义,因为它告诉我们两次C++程序员不应该使用C风格的字符串),但有一件事我很困惑是......有什么区别:

char ca[] = {'C', 'a', 't'};

和

char ca[] = "cat";

对于第一个,它表示它可能具有"灾难性"结果,因为c样式的字符串必须以空终止.但是第二个也不是c风格的字符串吗？为什么我不必键入"cat\0"或类似的东西？这不应该导致"灾难性后果"吗？

我正在阅读有关缓存写入策略的信息，我只想知道我是否正确理解了这一点。

当读取导致缓存未命中时，它将获取该内存块并将其放入缓存中。缓存写入未命中意味着程序要写入的内存位置不在缓存内，对吗？所以我正在阅读write-back的描述，根据维基百科如下：

最初，只对缓存进行写入。对后备存储的写入被推迟，直到包含数据的缓存块即将被新内容修改/替换。

那么缓存块的内存只能在读取期间被替换，对吗？并且写入只会更改内存特定位置中的数据（如果命中，这将在缓存块内），但它会使块内的实际内存位置保持不变，对吗？

这是我对它的理解，我只是想确保它是正确的。

编辑：等等，我猜在缓存未命中期间它也会替换/更新缓存块....

在找到插入排序的最坏情况分析时,有人可以逐步解释我们如何得到O(N ^ 2)吗？我正在阅读Cormen Intro to Algorithms一书的解释,但这种解释有点令人困惑.

我正在阅读一本书中的枚举,并给出了以下代码示例:

namespace FunWithEnums
{
    enum EmpType : byte
    {
        Manager = 10, 
        Grunt = 1,
        Contractor = 100,
        VicePresident = 9

    }
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("**** Fun with Enums *****");

            EmpType emp = EmpType.Contractor;
            EvaluateEnum(emp);
            Console.ReadLine();
        }

        static void EvaluateEnum(System.Enum e)
        {
            Array enumData = Enum.GetValues(e.GetType());

            for (int i =0; i < enumData.Length; i++)
            {
                Console.WriteLine("Name: {0}, Value: {0:D}", enumData.GetValue(i));
            }
            Console.WriteLine();
        }
}

我对于在forloop中打印出来的内容感到非常困惑.输出是

姓名:Grunt,价值:1

姓名:副总统,价值:9

姓名:经理,价值:10

名称:承包商,价值:100

但它如何获得每个枚举元素的名称和值？根据Microsoft文档,Array enumData = Enum.GetValues(e.GetType());应该只返回"指定枚举中的常量值的数组".我假设通过常数,它指的是"经理","咕噜","承包商","副总统",而不是10,1,100和9.那么为什么它返回每一对而不仅仅是名称员工类型？此外,以下代码的输出 …

我正在读我的书，它说“为其所有参数提供默认参数的构造函数也定义了默认构造函数”

所以在下面的代码中：

class Book {

    public: 

    int pages = 25;
    double price = 10.0;
    std::string font = "Times New Roman";

    Book() {}
    Book(int n, double p, std::string f): pages(n), price(p), font(f) { }
};

不带参数的构造函数和为其参数提供默认参数的构造函数都是默认构造函数吗？或者默认参数是否意味着第二个构造函数需要类似于：Book():pages(5),price(46),font("Times New Roman"){}