小编aJ.*_*aJ.的帖子

此问题为此处描述的问题提供了更清晰的信息.我做了一些调查,发现堆栈展开不会发生在下面的代码中:

class One
{
public:
    int x ;
};

class Wrapper
{
public:
    Wrapper(CString csText):mcsText(csText)
    {
        CString csTempText;
        csTempText.Format("Wrapper constructor :: %s\n", mcsText);
        OutputDebugString(csTempText);
    }

    ~Wrapper()
    {
        CString csTempText;
        csTempText.Format("Wrapper destructor :: %s\n", mcsText);
        OutputDebugString(csTempText);
    }
    CString mcsText;
};
class Test
{
    public:

    void notifyError()
    {
        try
        {
            int x = 10; 
        }
        catch(...)  {}
    }

    void OnRecvBuffer()
    {
        try
        {
            Wrapper a("AddRef");    
            One* p = NULL;
            p->x = 10;
        }
        catch(...)
        {
            notifyError();
        }   
    } …

我知道我可以遍历这样的字符串列表:

list<string>::iterator Iterator;
 for(Iterator = AllData.begin(); 
   Iterator != AllData.end();
   Iterator++)
 {
  cout << "\t" + *Iterator + "\n";
 }

但我怎么能这样做呢？

list<CollectedData>::iterator Iterator;
 for(Iterator = AllData.begin(); 
   Iterator != AllData.end();
   Iterator++)
 {
  cout << "\t" + *Iterator.property1 + "\n";
  cout << "\t" + *Iterator.property2 + "\n";
 }

或者,如果有人可以通过for_each循环解释如何执行此操作,那将非常有用,但从我读过的内容看起来更复杂.

非常感谢

char *sample = "String Value";

&sample 是指向指针的指针 "String Value"

上面的陈述是对的吗？

如果上述陈述正确,则相当于&sample我的声明是什么

char sample[] = "String Value"

有一些问题让我了解UTF-8,UTF-16,ASCII和ANSI之间的差异.在做了一些研究之后我有了一些想法,但是如果有人能够准确地解释它们之间的区别(包括每个的典型字符的字节表示),那将非常有用.

我问我的问题归结为

1) How do each of the above store characters as bytes
2) What are the differences between the above standards
3) What is a code page
4) Method of converting characters between the various types.

Run Code Online (Sandbox Code Playgroud)

非常感谢 :)

void problem3(void) {
    int overflowme[16];
    int x = (int) problem3; // x is the address of the first instr for problem3
    printf("hello world\n");
    overflowme[17] = x; 

我想知道(int)在C编程中做了什么.

当我erase-remove idiom从Scott Meyers的"Effective STL"一书中读到(第32项)时,我得到了这个问题.

vector<int> v; 
...
v.erase(remove(v.begin(), v.end(), 99), v.end());

remove 基本上返回"新逻辑结束"和原始范围的元素,从元素的"新逻辑结束"开始并继续,直到范围的实际结束是要从容器中删除的元素.

听起来不错.现在,让我问一下我的问题:

在上面的例子中,如果没有找到99就remove可以返回.它基本上是通过擦除方法.v.end()vector vpast-the-end-iterator

1. past-the-end-iterator传递给erase方法时会发生什么？标准是否说它是UB？
2. 如果它是未定义的行为,那么erase-remove idiomScott Meyer的书中的示例应该看起来像:

  vector<int> v; 
    ...
    vector<int>::iterator newEndIter = remove(v.begin(), v.end(), 99);
    if(newEndIter != v.end() )
    {
     v.erase(newEndIter, v.end();
    }  

有什么想法吗？

我正在尝试编写一些代码来将数据从对象类型字段(来自DataSet)转换为它的目标(类型)字段.我正在使用动态转换(至少尝试)它.它似乎适用于字符串,int,DateTime.

但它不适用于无符号类型(ulong,uint).下面是一个简单的代码,显示了我想要做的事情.如果将ul var类型从ulong更改为int,则可以正常工作.

有人有线索吗？

public class console
{

    public static void CastIt<T>(object value, out T target)
    {
        target = (T) value;
    }

    public static void Main()
    {
        ulong ul;
        string str;
        int i;
        DateTime dt;

        object ul_o = (object) 2;
        object str_o = (object) "This is a string";
        object i_o = (object)1;
        object dt_o = (object) DateTime.Now;

        Console.WriteLine("Cast");

        CastIt(ul_o, out ul);
        CastIt(str_o, out str);
        CastIt(i_o, out i);
        CastIt(dt_o, out dt);

        Console.WriteLine(ul);
        Console.WriteLine(str);
        Console.WriteLine(i);
        Console.WriteLine(dt.ToString());
    }

}

我正在编写一个递归函数,它接受一个char数组,它表示一个数字,以及一个指向该数组中数字的指针.该函数的要点是像++运算符一样递增数字.但是,当我尝试使用数字'819'时.它不会将其增加到'820',而是将其更改为'810'(它会增加最后一个数字,但不会执行我想要的递归).有人可以帮我解决这个问题吗？谢谢.

#include <stdio.h>

char* inc(char *num, char* p)
{   
    if( *p>='0' && *p<='8' )
    {
        *p++;
    }
    else if ( *p=='9' )
    {
        *p = '0';
        inc(num, --p);
    }

    return num;
}

main()
{
    char x[] = "819";

    printf("%s\n", inc(x, x+strlen(x)-1) ); //pass the number and a pointer to the last digit
}

只是想知道2NF可能没有必要.

Option 1. ORDERS {orderId (pk), custId (fk), total, date, status, ...}
   PARTS {orderId (pk), partsId (pk), qty, unitPrice, description, ...}

Option 2. ORDERS {orderId (pk), custId, total, date, status, ...}
   ORDER_PARTS {orderId (pk)(fk), partsId (pk)(fk), qty, ...}
   PARTS {partsId (pk), unitPrice, description, ...}

我认为大多数人都喜欢选项2,因为它是2NF,但我认为选项1更好,因为当我们查询它时它会更简单,更快捷.为什么在这种情况下我们需要2NF？

我创建了一个带有以下标志的命名管道:

• PIPE_ACCESS_DUPLEX - 双方读/写访问
• PIPE_TYPE_MESSAGE - 读取消息类型
• PIPE_WAIT - 阻止read\write

我从服务器端调用ConnectNamedPipe并等待客户端连接.

从客户端我调用CallNamedPipe连接到服务器并写入长度为N的数据.

在服务器端:

• 客户端连接后,调用PeekNamedPipe以获取要分配的缓冲区长度以读取数据缓冲区.
• 在获得确切的缓冲区大小(N)之后,我分配长度为N的缓冲区并调用ReadFile来从Pipe中读取数据.

问题:

• 问题是 - 在单处理器机器上,PeekNamedPipe API将缓冲区长度返回为0.因此,稍后ReadFile失败.
• 经过一些调查,我发现由于某些竞争条件,PeekNamedPipe API甚至在客户端将数据放入Pipe之前就会被调用.
• 知道如何解决这种竞争条件吗？我需要调用PeekNamedPipe来获取缓冲区大小,并且在数据可用之前无法调用PeekNamedPipe.

我想引入自定义标头来指示消息本身的缓冲区长度,但这听起来很多变化.

有没有更好更可靠的方法来获取从管道读取数据的长度？