C和C ++有什么区别?


回答 1:

C和CPP之间有很多差异。

C的缺点是CPP起源的原因。

  1. C是一种过程式编程语言,其中CPP是一种面向对象的编程语言.CPP支持抽象和封装,而C则没有.C使用Malloc和Calloc进行动态内存分配,而CPP使用了New和Delete.CPP开始支持内部的访问说明符Structures.CPP还支持Friend函数,函数重载和函数覆盖在多态下定义的Concept。

还有很多改进。


回答 2:

c和c ++之间的主要区别在于方法。 c基本上是一种面向过程的语言,这意味着使用c进行编程时,程序员首先想到的是解决该特定问题的程序的主要设计。首先是结构或逻辑。而在c ++中进行编程是面向对象的。这意味着首先引起程序员注意的是定义数据类型,如何设计类?如何创建对象?不同对象之间的关系应该是什么?等等..


回答 3:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 4:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 5:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 6:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 7:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 8:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 9:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 10:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 11:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 12:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 13:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 14:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 15:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 16:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 17:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 18:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 19:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 20:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 21:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 22:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 23:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 24:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 25:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 26:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 27:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 28:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 29:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 30:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 31:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 32:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 33:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 34:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 35:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 36:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 37:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 38:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 39:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。


回答 40:

他们有很大的不同。

在C ++中,“结构”和“类”之间的唯一区别是,默认情况下,“结构”成员是公共的,而默认情况下,“类”成员是私有的。

这意味着C ++中的“结构”可以具有构造函数,析构函数,成员函数等,就像C ++中的“类”一样。

您可以使用相同的结构和类,但是在混合的C和C ++代码中它们将不是相同的结构,除非您使用:

extern“ C” {
...
}

围绕结构声明。

因此,在这种情况下,请避免使用并行定义(通常是一个很好的经验法则),因为那样的话,您将不会传递指向同一对象的指针。