|
Thread Rules 1. This is not a "do my homework for me" thread. If you have specific questions, ask, but don't post an assignment or homework problem and expect an exact solution. 2. No recruiting for your cockamamie projects (you won't replace facebook with 3 dudes you found on the internet and $20) 3. If you can't articulate why a language is bad, don't start slinging shit about it. Just remember that nothing is worse than making CSS IE6 compatible. 4. Use [code] tags to format code blocks. |
On April 28 2016 05:22 Khalum wrote: [..] int err; [..]
brrrrrr...... int err; struct foo *a = alloc_foo(); if (!a) return fail(a, err);
What will this return? Same question for the goto implementation.
But you should be calling fail with a null pointer and whatever value was in memory when err was initialized.
|
Why try to write fail-safe code and then not even initialize 'err'?
|
On April 28 2016 05:46 Khalum wrote: Why try to write fail-safe code and then not even initialize 'err'?
I think that was an oversight by the quick code writing. In the second function you're passing the int err to the fail function, but you don't do anything with it so it might as well not be a parameter and just have void return.
The real argument is whether or not goto is more valuable than not having the overhead of an additional function call. When you're talking about low level kernel code written 30 years ago the additional overhead would be a problem.
|
I realize that I kinda derailed the discussion but I always have this 'brrrrrrrrr' feeling when I see things like that. Talking about higher level things is fine and great but people should start initializing their variables first.
|
On April 28 2016 04:39 Acrofales wrote:Show nested quote +On April 28 2016 04:33 Cyx. wrote:On April 27 2016 16:49 Morfildur wrote: Well, it was written when disk space actually still mattered. Saving 500 bytes on variable names made all the difference.
That said, someone should really at least fix the variable names to something easier to understand and add a few braces where they've been omitted.
Strongly disagree... don't touch code that works  Among the worst sins you can commit as a programmer is breaking things for the sake of pretty code. On April 27 2016 16:49 Morfildur wrote: The gotos are probably there to stay since C that close to the system often has those for performance reasons. I'd expect a modern compiler to optimize better without them, but Linux system and kernel programmers, do love their gotos since back in the day you could save a few processor cycles with them.
All in all, it's another example for why I don't engage in open source projects. All the projects I checked out have too many programmers with too little real world experience that write "clever" instead of good code, legacy code that the project creator wrote half-drunk 10 years ago that no one dares to touch for fear of breaking everything and too many people that have a hard-on for micro-optimizations while writing slow algorithms.
Also somewhat disagree that the gotos are for performance reasons. They're significantly more readable than the alternative. Using gotos properly in C can save you a ton of duplicated cleanup code, which is why those C programmers (Linux devs, GCC devs, BSD devs...) like them so much. eg: int func() { int err; struct foo *a = alloc_foo(); if (!a) return;
err = init_foo(a); if (err) { free_foo(a); return err; }
err = do_something_with_foo(a); if (err) { free_foo(a); return err; }
return 0; }
vs. int func() { int err; struct foo *a = alloc_foo(); if (!a) goto fail;
err = init_foo(a); if (err) goto fail;
err = do_something_with_foo(a); if (err) goto fail;
return 0;
fail: free_foo(a); return err; }
I mean, maybe a pretty trivial example, but there are places in the Linux kernel where this style of error handling reduces code duplication by a really significant amount. Can do that just fine without gotos. int func() { int err; struct foo *a = alloc_foo(); if (!a) return fail(a, err);
err = init_foo(a); if (err) return fail(a, err);
err = do_something_with_foo(a); if (err) return fail(a, err);
return 0; }
int fail(foo *a, int err) { free_foo(a); return err; }
And the advantage of this is that your code will never ever enter the fail code by mistake because you forgot a corner case in which there is no return statement above your label.
Yup, pretty much. In 99.9% of the situations gotos can be completely removed by wrapping the code in a function and returning from it. If you define it as inline, it probably even ends up as exactly the same assembly code. It's my observation though that many C programmers hate having extra functions for some reason. Probably has something to do with having to actually think of a proper function name instead of being able to use b2, b5, x or such as a function name.
|
Hey guys, I run into some problems that I cant figure out. When trying to build/buld&clean, netbeans tells me: Server.cpp:12:6: error: redefinition of ‘void Server::session(socket_ptr)’ In file included from Server.cpp:1:0:[pointing to session in Server.cpp] Server.h:30:10: error: ‘void Server::session(socket_ptr)’ previously defined here[pointing to the session-definition in Server.h]
I am not sure what the problem is since I don't redefine session. After building, Netbeans also marks "#Include "Server.h"" in Server.cpp as an error, while also stating "In file included from --- (Alt-Enter shows hints)". If I press alt enter, nothing happens.
Here is my code so far: Server.h
#ifndef SERVER_H #define SERVER_H #include <cstdlib> #include <iostream> #include <boost/bind.hpp> #include <boost/smart_ptr.hpp> #include <boost/asio.hpp> #include <boost/thread/thread.hpp> #include <string> #include <sstream> #include <vector>
using boost::asio::ip::tcp; typedef boost::shared_ptr<tcp::socket> socket_ptr;
class Server { private: int port; std::string messageTermiantor; const int max_length = 1024; public: Server(); Server(const Server& orig); virtual ~Server(); void session(socket_ptr sock){}; std::vector<std::string> split(std::string str, char delimiter) {}; void server(boost::asio::io_service& io_service, short) {}; void loop();
};
#endif /* SERVER_H */
Server.cpp:
#include "Server.h"
Server::Server() { }
Server::Server(const Server& orig) { }
Server::~Server() { }
void Server::session(socket_ptr sock){ };
std::vector<std::string> split(std::string str, char delimiter) { std::vector<std::string> internal; std::stringstream ss(str); std::string tok;
while (getline(ss, tok, delimiter)) { internal.push_back(tok); } return internal; }
|
I'd suggest removing brackets "{ }" from the Server.h as I am pretty sure Netbeans interprets it as a "first" definition of your session function.
|
|
Hyrule18968 Posts
|
Isn't that a standard error?
Also, use CMake :3
|
On April 29 2016 03:09 Blisse wrote: Isn't that a standard error?
Also, use CMake :3
I am too stupid to properly set up a makefile and cant install anything on the lab-pcs unfortunately.
|
On April 27 2016 23:42 WarSame wrote:Show nested quote +On April 27 2016 18:41 Wrath wrote:On April 27 2016 10:43 WarSame wrote:Folks, looking for a bit of help with mean.io. I dled and installed node, mongodb and git. I then init a directory and run npm install inside of it. I then run gulp to start the server. This throws errors that I'm missing various modules such as 'mongoose', 'async', etc. but these should be installed from the npm install, correct? The exact error is + Show Spoiler +E:\mean_workspace\monoprobability\node_modules\q\q.js:155 throw e; ^
Error: Cannot find module 'mongoose' at Function.Module._resolveFilename (module.js:325:15) at Function.Module._load (module.js:276:25) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at Object.<anonymous> (E:\mean_workspace\monoprobability\node_modules\meanio-users\server\models\user.js:6:17) at Module._compile (module.js:409:26) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at requireModel (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\index.js:116:19) at E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:21:7 at Array.forEach (native) at walk (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:16:25) at E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:23:7 at Array.forEach (native) at Object.walk (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:16:25) at MeanUserKlass.Module (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\index.js:134:14) at new MeanUserKlass (E:\mean_workspace\monoprobability\node_modules\meanio-users\app.js:10:10) at Object.<anonymous> (E:\mean_workspace\monoprobability\node_modules\meanio-users\app.js:21:16) at Module._compile (module.js:409:26) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at Module.activate (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\dependablelist.js:52:15)
When I tried to start using mean.io on another computer it worked fine so it is almost certainly a problem with my current environment. When I look inside of my root's node_modules folder it is missing both 'async' and 'mongoose'. Are they supposed to be in that folder? Can't you copy them from the other computer and see if that solves the issue for you? The other computer is a work computer which disables copying files :/ Show nested quote +On April 27 2016 19:43 Acrofales wrote:On April 27 2016 10:43 WarSame wrote:Folks, looking for a bit of help with mean.io. I dled and installed node, mongodb and git. I then init a directory and run npm install inside of it. I then run gulp to start the server. This throws errors that I'm missing various modules such as 'mongoose', 'async', etc. but these should be installed from the npm install, correct? The exact error is + Show Spoiler +E:\mean_workspace\monoprobability\node_modules\q\q.js:155 throw e; ^
Error: Cannot find module 'mongoose' at Function.Module._resolveFilename (module.js:325:15) at Function.Module._load (module.js:276:25) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at Object.<anonymous> (E:\mean_workspace\monoprobability\node_modules\meanio-users\server\models\user.js:6:17) at Module._compile (module.js:409:26) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at requireModel (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\index.js:116:19) at E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:21:7 at Array.forEach (native) at walk (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:16:25) at E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:23:7 at Array.forEach (native) at Object.walk (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\util.js:16:25) at MeanUserKlass.Module (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\index.js:134:14) at new MeanUserKlass (E:\mean_workspace\monoprobability\node_modules\meanio-users\app.js:10:10) at Object.<anonymous> (E:\mean_workspace\monoprobability\node_modules\meanio-users\app.js:21:16) at Module._compile (module.js:409:26) at Object.Module._extensions..js (module.js:416:10) at Module.load (module.js:343:32) at Function.Module._load (module.js:300:12) at Module.require (module.js:353:17) at require (internal/module.js:12:17) at Module.activate (E:\mean_workspace\monoprobability\node_modules\meanio\lib\core_modules\module\dependablelist.js:52:15)
When I tried to start using mean.io on another computer it worked fine so it is almost certainly a problem with my current environment. When I look inside of my root's node_modules folder it is missing both 'async' and 'mongoose'. Are they supposed to be in that folder? Is your internet stable, and no timeout problems? I've had issues with npm skipping stuff if it cannot get it sufficiently quickly, and then claiming success all the same. rerunning npm install usually works, but sometimes it's really confused and you need to throw away your node_modules and start again. either that, or your package.json is wrong. Yup, my internet is pretty stable here. I've run the command like 5 times in a row and I've deleted and reinited the app ~5 times too, so that shouldn't be it. My package.json is simply the default mean.io package, so it should be fine. I know it's a dumb question but... Does your package.json have async and mongoose in dependencies section? The only other thing I can think about is async and mongoose getting deleted from central npm repo. I don't think internet connection creates major issues because I might be having one of the shittiest internet connections in the entire thread and still didn't have any issues with npm claiming success but not downloading dependencies. Regardless, you can run:
npm install --save async mongoose
and solve your problem that way.
|
I got another problem. I have a hard time understanding boost::bind in combination with a class. I got:
void Server::session(socket_ptr sock){...}
Without having session() as a function of a class, I can use:
boost::thread t(boost::bind(session, sock));
In a class I thought I had to do this:
void Server::server(boost::asio::io_service& io_service, short port) { . . .
boost::thread t(boost::bind(&Server::session, ref(this), _1)(sock)); }
Needless to say, it doesn't work.
|
On April 29 2016 19:47 Artesimo wrote: void Server::server(boost::asio::io_service& io_service, short port) { . . .
boost::thread t(boost::bind(&Server::session, ref(this), _1)(sock)); }
Needless to say, it doesn't work. I don't think you need the 'ref(this)' call - the Boost docs seem to imply that you can call that as just
boost::thread t(boost::bind(&Server::session, this, _1)(sock));
Although this raises the question, why bother binding it at all if you immediately call it with 'sock' as an argument?
EDIT: read this again and I'm pretty sure your problem is actually that you're passing the bound function to boost::thread() in the first case, but in the second case you're *calling* the bound function and passing the result. These things are not equivalent:
boost::thread t(boost::bind(&Server::session, this, _1)(sock)); boost::thread t(boost::bind(&Server::session, this, sock));
I think you want the second one, not the first.
|
On April 29 2016 06:04 Artesimo wrote:Show nested quote +On April 29 2016 03:09 Blisse wrote: Isn't that a standard error?
Also, use CMake :3 I am too stupid to properly set up a makefile and cant install anything on the lab-pcs unfortunately.
You can get away even with simple makefiles for the most part.
|
Has anyone tried C++11/14 yet? What do you like and what don't you like?
|
On April 30 2016 07:23 Shield wrote: Has anyone tried C++11/14 yet? What do you like and what don't you like? I haven't used it too heavily yet outside of some of the quality of life improvements.
I enjoy using the new type inference stuff. For example, auto is very nice and helps with not having to always type out full type names, especially when the type doesn't exactly help with readability.
Range-based iteration is also nice. Compare:
for (std::vector<SomeObj>::iterator it = vec.begin(); it != vec.end(); ++it) { // Do stuff }
for (auto &elem : vec) { // Do stuff }
I like using lambda functions (closures) as well. When used effectively, they can simplify some code and make it easier to read.
The changes to initialization are a welcome addition also. There's also been some changes introduced that allow you to lean on the compiler a little more, which is nice. For example: constexpr, strongly typed enumerations, etc.
Like I said, I haven't used too many of the more advanced features, but just these ones and a few others result in much cleaner and readable code than before when they're leveraged effectively. Overall, I like the introduced changes.
I'd recommend this book if you'd like to learn more: https://www.amazon.ca/Effective-Modern-Specific-Ways-Improve/dp/1491903996
|
On April 30 2016 07:58 Mr. Wiggles wrote:Show nested quote +On April 30 2016 07:23 Shield wrote: Has anyone tried C++11/14 yet? What do you like and what don't you like? I haven't used it too heavily yet outside of some of the quality of life improvements. I enjoy using the new type inference stuff. For example, auto is very nice and helps with not having to always type out full type names, especially when the type doesn't exactly help with readability. Range-based iteration is also nice. Compare: for (std::vector<SomeObj>::iterator it = vec.begin(); it != vec.end(); ++it) { // Do stuff } for (auto &elem : vec) { // Do stuff } I like using lambda functions (closures) as well. When used effectively, they can simplify some code and make it easier to read. The changes to initialization are a welcome addition also. There's also been some changes introduced that allow you to lean on the compiler a little more, which is nice. For example: constexpr, strongly typed enumerations, etc. Like I said, I haven't used too many of the more advanced features, but just these ones and a few others result in much cleaner and readable code than before when they're leveraged effectively. Overall, I like the introduced changes. I'd recommend this book if you'd like to learn more: https://www.amazon.ca/Effective-Modern-Specific-Ways-Improve/dp/1491903996
Thanks, I know what you mean. I'm also reading that book. However, my colleagues are usually against auto outside ranged for loops. To be honest, I can't say it helps there too much either.
for (const auto& elem : vec) {
}
for (const SomeObj& elem : vec) {
}
I'd say the latter is far from unreadable and you don't use iterator's long syntax.
|
On April 30 2016 08:05 Shield wrote:Show nested quote +On April 30 2016 07:58 Mr. Wiggles wrote:On April 30 2016 07:23 Shield wrote: Has anyone tried C++11/14 yet? What do you like and what don't you like? I haven't used it too heavily yet outside of some of the quality of life improvements. I enjoy using the new type inference stuff. For example, auto is very nice and helps with not having to always type out full type names, especially when the type doesn't exactly help with readability. Range-based iteration is also nice. Compare: for (std::vector<SomeObj>::iterator it = vec.begin(); it != vec.end(); ++it) { // Do stuff } for (auto &elem : vec) { // Do stuff } I like using lambda functions (closures) as well. When used effectively, they can simplify some code and make it easier to read. The changes to initialization are a welcome addition also. There's also been some changes introduced that allow you to lean on the compiler a little more, which is nice. For example: constexpr, strongly typed enumerations, etc. Like I said, I haven't used too many of the more advanced features, but just these ones and a few others result in much cleaner and readable code than before when they're leveraged effectively. Overall, I like the introduced changes. I'd recommend this book if you'd like to learn more: https://www.amazon.ca/Effective-Modern-Specific-Ways-Improve/dp/1491903996 Thanks, I know what you mean. I'm also reading that book. However, my colleagues are usually against auto outside ranged for loops. To be honest, I can't say it helps there too much either. for (const auto& elem : vec) {
}
for (const SomeObj& elem : vec) {
}
I'd say the latter is far from unreadable and you don't use iterator's long syntax. I'd say it depends somewhat on the code you're working with. It also helps when you're working with stuff that makes heavy use of templating, where the type names by themselves might be gargantuan, and then it definitely improves readability if having the type explicitly typed out isn't required.
Another advantage of using auto is that it makes the code somewhat more maintainable as well, since type changes don't require additional code changes except where it's declared. For example, if I changed some type in a class to something with the same interface, I now don't need to go through the code and fix up anywhere it's being used. This can also be gotten around with sufficient tooling, on the other hand.
All in all, the best thing to do is to stay consistent with what your colleagues are doing, I'd say. If the benefits in your case are only marginal, it makes more sense to keep the code style consistent than to make changes that don't have full agreement across the team.
|
|
|
|
|