C basic structure, characteristics of the constructor in C?

using systme;

using ;

using ;

using ;

Utilize the files of the system. It is equivalent to include <> in C

This place generally does not need to be modified, when you write some small programs, for example, if you want to use SQL databases, you may have to add using;

A self-named space that can be used elsewhere;

class program

define a class;

static void main(string args) main function.

The program starts executing from this function.

output text to the screen.

Wait for a character to be entered. This sentence can be removed, you don't need it in this program.

If you can't understand this, I personally think that you may not have good C language skills, so let's take a good look at the basics.

Of course, there are constructors, but note that the definition of a constructor destructor is different from that of a normal function.

public struct s

In addition, there are products on the stationmaster's group **, cheap ***.

It doesn't have to be static, the constructor is mainly used to create objects, and the constructor is how to implement the defined function.

As I understand it, functions and methods are just different words.

In fact, there is no such thing as a function in C, that is to say, as long as it is in an object, it is a member method, and a function is a process inherited from other languages, that is to say, we generally call a function that does not belong to any object a function, and as long as there is a function that belongs to an object, it is called a member method of the object - so the reason why we no longer use the title of function. Function is a concept for SP, that is, process-oriented programming, and there is no such function in object-oriented, so there is no such name for function.

However, due to the bad habits of the previous language, we can also call member methods functions, which are actually member methods. So both the constructor and the constructor refer to the same concept. While some people call static methods functions, they are still static methods.

There is a term in object orientation where constructors can be overloaded, i.e. there are several different forms, different parameter lists, and the same object member method with the same name is overloaded. It doesn't matter if it's static or ordinary, it's the same. So there is no conceptual difference between the two.

Sequential structure, selection structure, cyclic structure.

1.Sequential structure.

The sequential structure means that the operations in the program are executed in the order in which they appear, and the characteristics of this structure are: the program starts from the entry point A, and performs all the operations in order until the exit point B, so it is called the sequential structure.

2.Select the structure.

Selecting a structure indicates that a program's processing steps have branched, and it needs to select one of the branches to execute according to a specific condition. There are three types of selection structures: single choice, double choice and multiple choice.

3.Circular structure.

A loop structure means that a program performs one or more actions over and over again until a condition is false (or true) before terminating the loop. The main thing in the loop structure is: when is the loop executed?

What operations need to be performed in a loop? There are two basic forms of the loop structure: the current cycle and the until the cycle, and when the cycle is executed depends on the conditions.

A structure is a value type -- if you create an object from a structure and assign that object to a variable, the variable contains all the values of the structure. When you copy a variable that contains a structure, all data is copied, and any modifications made to the new copy do not alter the data of the old copy. Since the structure doesn't use references, the structure doesn't identify -- two instances of a value type with the same data are indistinguishable.

All value types in C essentially inherit from ValueType, which inherits from Object.

The structure has the following characteristics:

A struct is a value type, while a class is a reference type.

Unlike classes, the instantiation of a structure can be done without the new operator.

Constructors can be declared, but they must have arguments.

A structure cannot inherit from another structure or class, and cannot serve as a basis for a class. All structures are inherited directly from , which is inherited from .

The structure can implement the interface.

A struct and a class are the difference between a value type and a reference type.

If you want to store a lot of fields, the structure is very resource-efficient, but if you want to do something, you'll need to use classes.

But any class that the structure can do can do. The structure that classes can do is something that a lot of them can't.

Structs are of value types, while classes are of reference types.

When you want to describe a class of objects, if this kind of object has a lot of functions and cumbersome, then it is recommended to use a class, which is a functional component, and classes can call each other to achieve message passing, but the structure is only a collection of simple value types in the end.

Struct? When an object has a fixed property, you can create a struct to maintain the parameters and pass through the object. You can put the parameters of the same object into an instance of an object for querying and passing parameters.

Class: A class is a reference type allocated on the heap, and the instance of the class is assigned just a copy of the reference, all pointing to the same piece of memory allocated by the actual object.

Classes have constructors and destructors.

Classes can inherit and be inherited.

Structure: A structure is a value type that is allocated on the stack (although the access speed of the stack is faster than that of the heap, but the resources of the stack are limited), and the assignment of the structure will be allocated to produce a new object.

Structs don't have constructors, but they can be added. A structure without a destructor structure cannot inherit from or be inherited from another structure, but it can inherit from an interface just like a class.