小编Yuu*_*shi的帖子

在我插入数学部分之前,我完成的程序运行得很好.完成数学部分后,我构建了代码,没有出现任何错误.但是,当我尝试调试我的程序时,我得到了这个提示:"Reciept.exe中0x4f7ccb1a(msvcr100d.dll)的未处理异常:0xC0000005:访问冲突写入位置0x4e65ab48."

我首先想到的是数学,但后来我删除它并再次运行程序,应该像之前那样出现的事情没有.同样的提示出现了.

你能告诉我发生了什么吗？

这是我的代码:

#include <iostream>
#include <string>
#include <iomanip>

using namespace std;

struct menuItemType
{
    string menuItem;
    double menuPrice;
    double sum;
    double amountTotal;
    double tax;
};

void getData(menuItemType menuList[8]);
void printCheck(menuItemType menuList[8]);
void showMenu(menuItemType menuList[8]);

int main()
{
    menuItemType menuList[8];
    getData(menuList);
    showMenu(menuList);
    printCheck(menuList);

    system ("pause");
    return 0;
}

void getData(menuItemType menuList[8])
{
    menuList[1].menuItem = "Plain Egg"; 
    menuList[1].menuPrice = 1.45;
    menuList[2].menuItem = "Bacon and Egg";
    menuList[2].menuPrice = 2.45;
    menuList[3].menuItem = "Muffin";
    menuList[3].menuPrice = 0.99;
    menuList[4].menuItem = "French Toast";
    menuList[4].menuPrice = …

我正在尝试在D中编写非常简单的代码,但是我遇到了一个标准库模板函数(特别是nextPermutation来自std.algorithm)的问题.

我正在尝试做的关键是创建pandigital数字的所有排列(即,包括所有值1到9的数字恰好一次).

为此,我做了以下事情:

import std.algorithm;
import std.conv;

int[] pandigitals()
{
    char[] initial = "123456789".dup;
    auto pan = [to!int(initial)];
    while(nextPermutation!(initial)) {
       pan ~= to!int(initial);
    }
    return pan;
}

这给了我错误:

错误:无法解析nextPermutation的类型!(初始)

我也尝试过显式设置类型:

while(nextPermutation!("a<b", char[])(initial))

但是,这会给出一个错误,说它与模板不匹配:

错误:模板实例std.algorithm.nextPermutation( "A <B",CHAR [])不匹配,如果(isBidirectionalRange BidirectionalRange模板声明nextPermutation(别名更少= "A <B",BidirectionalRange)(参考文献BidirectionalRange范围)&&! hasSwappableElements!BidirectionalRange)

呼叫的正确形式是什么？

在测试一个包含弱引用的类时,我偶然发现了这个有点奇怪的行为:Python垃圾收集器似乎缺少列表中的最后一个元素.一个最小的例子:

class Test(object):

    def __init__(self, i):
        self.i = i

    def __del__(self):
        print('Deleting Test {0}'.format(self.i))

if __name__ == '__main__':

    x = [Test(i) for i in range(5)]
    for t in x:
        print(t.i)
    x = []

以上将打印:

0

1

2

3

4

删除测试3

删除测试2

删除测试1

删除测试0

无论创建的对象列表(10,100,1000等)的大小如何,都会发生这种情况.为了仔细检查是否是这种情况,我试图强制进行垃圾收集,并确保在将原始列表设置为[]或调用之后仍然可以使用对原始列表值的弱引用(并且未标记为已死)del x:

import weakref
import gc

z = None

if __name__ == '__main__':
    x = [Test(i) for i in range(5)]
    for t in x:
        print(t.i)

    z = weakref.ref(x[4])
    x = []
    gc.collect(2)
    print(z().i) …

给定一个模板和一个更专业的重载:

template <typename T>
const T& some_func(const T& a, const T& b) 
{
    std::cout << "Called base template\n";
    return (a < b) ? a : b; 
}

template <typename T>
T* const& some_func(T* const& a, T* const& b) 
{
    std::cout << "Called T* overload\n";
    return (*a < *b) ? a : b; 
}

然后以下按预期工作:

int main()
{
    std::cout << some_func(5.3, 6.2) << "\n";
    double a = 1;
    double b = 2;
    double *p = &a;
    double *q = &b;
    const …

当我尝试将作为类成员的int []中的元素连接成String时,它可以正常工作.但是当我使用temp int [](从Arrays.copyOf生成)执行相同的过程时,我得到了乱码.我不明白为什么会这样.我的代码的简化版本如下:

import java.util.*;
import java.io.*;

public class Test {

    public int[] arr;                       

    public Test(int[] arr) {                                             
        this.arr = arr;                                                        
    }

    public void fn() {
        // ...
        int[] temp = Arrays.copyOf(arr, arr.length);
        System.out.println(this);
        System.out.println(temp);
    }                                                                       

    /*
     * Takes an integer array as input and returns a string representation
     * of the elements in the array.
     */
    public String arrayToString(int[] arr) {
        String s = "[";
        int i = 0;
        while(i < (arr.length - 1)) {
            s = s …

许多程序员告诉我,using namespace <x>在头文件中有一个语句是个坏主意.我一直盲目地遵循这个建议,直到现在却不明白为什么会如此.现在我正在开发一个包含大量命名空间的非常复杂的项目.有时我发现在开头告诉编译器关于命名空间而不是每次都要输入nested ::'是太诱人了.例:

ALongNameSpaceName::LongerNamespaceName::BasicUtilityFunctionUsedVeryCommonly

这条规则背后的理由是什么？在哪些情况下我可以忽略此规则？

我正在尝试执行与数组比较的函数,如果它们相同则返回true.现在数组很简单,稍后会推进但我仍然坚持使用该testEqual功能.所以这是代码

int n = 5;
int array[5] = {5,10,3,4,7};
bubbleSort(pole,n);

int array2[5] = {3,4,5,7,10};
testEqual( array , array2 , "bubbleSort");

这是testEqual我需要在阵列上重制的功能,但我不知道如何.

bool testEqual(int i1, int i2, const string testName) {
    bool myresult = (i1 == i2);
    return myresult;
}

像bubbleSort这样的其他功能很好,我只需要重新制作testEqual.

我编写了一个compare()函数来排序vector< vector < int > >并崩溃.

具体来说,如果我打电话sort(u.begin(),u.end());没有发生崩溃.但是,如果我将sort(u.begin(),u.end(), compare);其称为崩溃,即使compare()只是简单地返回true而没有更多的代码.我的代码出了什么问题？

bool compare_4sum(vector<int>& a, vector<int>& b){
    return true;
}

void test(){    
    vector<int> x; 
    x.push_back(1);
    x.push_back(2);
    vector<int> x2;
    x2.push_back(2);
    x2.push_back(4);    
    vector<vector<int>> u;    
    u.push_back(x);
    u.push_back(x2);
    sort(u.begin(),u.end(), compare);
}

Java代码示例:

public String toString() {

   return (title + '\n' + border + '\n' + getEmpID() + " " 
           + getLastName() + " " + getFirstName() + " " 
           + getHours() + " " + getRate() + " " + getGross() + border);}

正如您所看到的那样,它是一个很长的toString覆盖.

将代码行分解为较小位的标准位置在哪里.之前'+'的'" "'？请帮忙!:)

此外,如果你能告诉我如何正确放置{}那将是伟大的.