Thanks. So again, hi there fellow C/C++ developers. You guys are generally the smartest out of all developers out there so I hope for your help. I've recently read Clean architecture by Robert Martin (a great book and it is worth attention because the author is obviously very smart and experienced, and everyone who bashes his book does not know what they are talking about). In the book, we have this: NOT ALL COMPONENTS SHOULD BE STABLE If all the components in a system were maximally stable, the system would be unchangeable. This is not a desirable situation. Indeed, we want to design our component structure so that some components are unstable and some are stable. The diagram in Figure 14.8 shows an ideal configuration for a system with three components. The changeable components are on top and depend on the stable component at the bottom. Putting the unstable components at the top of the diagram is a useful convention because any arrow that points up is violating the SDP (and, as we shall see later, the ADP). The diagram in Figure 14.9 shows how the SDP can be violated. Flexible is a component that we have designed to be easy to change. We want Flexible to be unstable. However, some developer, working in the component named Stable, has hung a dependency on Flexible. This violates the SDP because the I metric for Stable is much smaller than the I metric for Flexible. As a result, Flexible will no longer be easy to change. A change to Flexible will force us to deal with Stable and all its dependents. To fix this problem, we somehow have to break the dependence of Stable on Flexible. Why does this dependency exist? Let’s assume that there is a class C within Flexible that another class U within Stable needs to use (Figure 14.10). We can fix this by employing the DIP. We create an interface class called US and put it in a component named UServer. We make sure that this interface declares all the methods that U needs to use. We then make C implement this interface as shown in Figure 14.11. This breaks the dependency of Stable on Flexible, and forces both components to depend on UServer. UServer is very stable (I = 0), and Flexible retains its necessary instability (I = 1). All the dependencies now flow in the direction of decreasing I. Abstract Components You may find it strange that we would create a component—in this example, UService—that contains nothing but an interface. Such a component contains no executable code! It turns out, however, that this is a very common, and necessary, tactic when using statically typed languages like Java and C#. These abstract components are very stable and, therefore, are ideal targets for less stable components to depend on. When using dynamically typed languages like Ruby and Python, these abstract components don’t exist at all, nor do the dependencies that would have targeted them. Dependency structures in these languages are much simpler because dependency inversion does not require either the declaration or the inheritance of interfaces. Illustrations are as follows: i . imgur . com / GgWawn3 . png i . imgur . com / MVPqSrr . png

So Robert Martin wrote a whole chapter explaining incaplusation and polymorphism What a waste of resources

Is this a post that says that Martin's opinions are subjective, his books should not be followed as cargo cult and he is an old man yelling at things?

Howdyaknow？

So my question is: 1. How, and why, is this strategy is necessary in statically typed languages? Is it something enforced by the language itself, or is it just a software architecture principle which only applies to static languages (like the interface segregation principle, which Martin demonstrates to reflect problems of static languages but not dynamic ones)? I've asked my C++ senior dev buddy if it is something enforced by the language and he said that he needs some time to think about it. He has not yet found a single example where a language would enforce the necessity to use an interface.

I am convinced that we should force lock up people like you in online mental asylums like r/cognitivetesting to crush your ego and self confidence with some silly numbers displayed on the screen.

Thanks. So again, hi there fellow C/C++ developers. You guys are generally the smartest out of all developers out there so I hope for your help. I've recently read Clean architecture by Robert Martin (a great book and it is worth attention because the author is obviously very smart and experienced, and everyone who bashes his book does not know what they are talking about). In the book, we have this: NOT ALL COMPONENTS SHOULD BE STABLE If all the components in a system were maximally stable, the system would be unchangeable. This is not a desirable situation. Indeed, we want to design our component structure so that some components are unstable and some are stable. The diagram in Figure 14.8 shows an ideal configuration for a system with three components. The changeable components are on top and depend on the stable component at the bottom. Putting the unstable components at the top of the diagram is a useful convention because any arrow that points up is violating the SDP (and, as we shall see later, the ADP). The diagram in Figure 14.9 shows how the SDP can be violated. Flexible is a component that we have designed to be easy to change. We want Flexible to be unstable. However, some developer, working in the component named Stable, has hung a dependency on Flexible. This violates the SDP because the I metric for Stable is much smaller than the I metric for Flexible. As a result, Flexible will no longer be easy to change. A change to Flexible will force us to deal with Stable and all its dependents. To fix this problem, we somehow have to break the dependence of Stable on Flexible. Why does this dependency exist? Let’s assume that there is a class C within Flexible that another class U within Stable needs to use (Figure 14.10). We can fix this by employing the DIP. We create an interface class called US and put it in a component named UServer. We make sure that this interface declares all the methods that U needs to use. We then make C implement this interface as shown in Figure 14.11. This breaks the dependency of Stable on Flexible, and forces both components to depend on UServer. UServer is very stable (I = 0), and Flexible retains its necessary instability (I = 1). All the dependencies now flow in the direction of decreasing I. Abstract Components You may find it strange that we would create a component—in this example, UService—that contains nothing but an interface. Such a component contains no executable code! It turns out, however, that this is a very common, and necessary, tactic when using statically typed languages like Java and C#. These abstract components are very stable and, therefore, are ideal targets for less stable components to depend on. When using dynamically typed languages like Ruby and Python, these abstract components don’t exist at all, nor do the dependencies that would have targeted them. Dependency structures in these languages are much simpler because dependency inversion does not require either the declaration or the inheritance of interfaces. Illustrations are as follows: i . imgur . com / GgWawn3 . png i . imgur . com / MVPqSrr . png

any pdf

https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/pdfreference1.0.pdf

Today's weather is very good and my mood is also very good

Today's weather is very good and my mood is also very good

NEED FRESHERS WHO COMPLETED THE DEGREE AFTER 2018 FOR LEADING MNC , WE CAN DO BACK DOOR PROCESS ALSO .INTERESTED PING ME DIRECTLY

NEED FRESHERS WHO COMPLETED THE DEGREE AFTER 2018 FOR LEADING MNC , WE CAN DO BACK DOOR PROCESS ALSO .INTERESTED PING ME DIRECTLY

NEED FRESHERS WHO COMPLETED THE DEGREE AFTER 2018 FOR LEADING MNC , WE CAN DO BACK DOOR PROCESS ALSO .INTERESTED PING ME DIRECTLY

I m noob

I m noob

/ban crypto bot

@K11M1 kill this too...

Im trying to take a sentence a sentence as input and store each word in separate array, How can I achieve that in C?

Im trying to take a sentence a sentence as input and store each word in separate array, How can I achieve that in C?

#res

What do you have do far? If you don't mind having hard limit of maximal word length and word count I would create an array of char arrays and then just go char by char copy it into (inner) array and whe you find space just put \0 into current array and start copying chars to the next (inner) array

Since when does GCC accept extra semicolons on function calls?

Hello

/warns

Since when does GCC accept extra semicolons on function calls?

Semicolons are used to end statements. An empty semicolon is a null expression, in other words, nothing. You can add multiple empty semicolons wherever you can use a semicolon to end an statement, as it does nothing. https://en.cppreference.com/w/cpp/language/statements

so it's not a bug?

For example, for(;;); is well defined as an infinite loop that does nothing (keep in mind that infinite loops themselves are undefined behaviour)

What do you have do far? If you don't mind having hard limit of maximal word length and word count I would create an array of char arrays and then just go char by char copy it into (inner) array and whe you find space just put \0 into current array and start copying chars to the next (inner) array

Im trying to take a sentence a sentence as input and store each word in separate array, How can I achieve that in C?

There is many ways to do the same thing it really depends on how much info you want to access the data, if you want any meta data stored, thread safety, POSIX compliance, what libraries you want to use, technically you could do it without cstdlib. Do you want error handling, etc … How far down the rabbit hole do you want to go.

Absolute dead simple code Something a noob would write

So yeah for loop through a null terminated char * array until you find a ‘\0’, copy one char at a time, compare current char with ‘ ‘ character if you find that, move on to assigning the next word. If you’re using dynamic arrays though, are you allocating memory with malloc?

Did they already show you examples using buffers?