ㅤManjeet Saini sent a code, it has been re-uploaded as a file

I need help in reading unicode file in c, here is the code

Why not read the file until EOF ?

I need help in reading unicode file in c, here is the code

Invalid bytes in buffer

I am not very much aware about unicode format,

That's depend on what sizeof(wchar_t) return

uh, where to specify that? I am reading a normal text file to read,

uh, where to specify that? I am reading a normal text file to read,

Every text file has an encoding. There are multiple encodings that can encode all unicode code points. Some examples are utf-8 (the most common encoding), utf-16, utf-32, and many more.

Ok, for the text file, my text editor showing the utf-8 format

Means the bytes size for one character?

Sometimes it means that, but don't take it for granted and search for the specific encoding you're dealing with. In the case of utf8 it is a variable length encoding, meaning characters have different byte sizes (there are characters that use only 1 byte, but others may use 2, 3, 4, up to 6 bytes)

So issue is with the byte size that i am providing, which is sizeof(wchar_t) == 4?

So issue is with the byte size that i am providing, which is sizeof(wchar_t) == 4?

Sorry replying so late, but what is the exact error you're getting？

hello guys

I need c course pdf

Help me on how to become a full stack C/C++ developer

there is no such thing

Help me on how to become a full stack C/C++ developer

#include <string.h> int main() { int stacksize = 100; void* stack[stacksize]; memset(stack, 1, sizeof(stack)); return 0; }

#include <string.h> int main() { int stacksize = 100; void* stack[stacksize]; memset(stack, 1, sizeof(stack)); return 0; }

What about now？

You should use sizeof(stack)

So issue is with the byte size that i am providing, which is sizeof(wchar_t) == 4?

Fox is now approved by the group admin and can send messages without any restrictions Thank you, this bot is genuinely annoying. See spam? Quote the spam message in the group and reply with /spam

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

I'd not be so generous with words in this chat

I'd rather ask a C dev when I don't know something than a PHP dev because C has higher entry threshold and filters out less talented developers. Even I was not able to learn C.

Thus a C dev is more narrow-minded

I'd rather ask a C dev when I don't know something than a PHP dev because C has higher entry threshold and filters out less talented developers. Even I was not able to learn C.

I'd rather ask a C dev when I don't know something than a PHP dev because C has higher entry threshold and filters out less talented developers. Even I was not able to learn C.

What is hard about C? It's really one of the easiest and one of the stupidest languages out there

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 also not going to do it in foreseeable future because there are simply no entry-level C positions so far, and imitating a middle C developer for a newbie like me would be difficult.

can you stfu for one second please when it gets to C-related talk?

Can you just admit that you're stupid?

why would I admit, I can come out as stupid

I don't think anybody is going to read all of this and really understand. So, I'd advise to rephrase it on your words

Cum out please

I may sound rude but If someone is not going to read something technical written by Robert Martin - okay, if someone has not read his Clean Architecture yet - they are instantly not qualified to answer this question. (Just like people who can't understand that they better watch TV shows not in the order of their to-watch list but in the order of what looks most promising to them to avoid wasting their time on bad shows, their IQ is too low to understand my favorite arthouse anime, and in this case, they should not really be watching it because it is not made for them.)

I may sound rude but If someone is not going to read something technical written by Robert Martin - okay, if someone has not read his Clean Architecture yet - they are instantly not qualified to answer this question. (Just like people who can't understand that they better watch TV shows not in the order of their to-watch list but in the order of what looks most promising to them to avoid wasting their time on bad shows, their IQ is too low to understand my favorite arthouse anime, and in this case, they should not really be watching it because it is not made for them.)

I may sound rude but If someone is not going to read something technical written by Robert Martin - okay, if someone has not read his Clean Architecture yet - they are instantly not qualified to answer this question. (Just like people who can't understand that they better watch TV shows not in the order of their to-watch list but in the order of what looks most promising to them to avoid wasting their time on bad shows, their IQ is too low to understand my favorite arthouse anime, and in this case, they should not really be watching it because it is not made for them.)

Reading Martin's book is not making you "qualified"

I know about it. I asked this exact question because I know that I am not smart enough to figure it out on my own and I doubt if my answer to this question is ever correct. If you don't have anything to say then please just shut up. I am not going to "make it as pleasing to answer as possible", everything needed to answer my question is in the question himself. I highly doubt that I would be able to accurately rephrase Robert Martin because he is Robert Martin, and I am a mere mortal aspiring web developer.

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

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

Not answering your question, but now that you mention bob martin: https://www.reddit.com/r/programming/s/CPSkfqNTQs