If you use a halfway decent IDE spotting syntax errors is even easier, too, as they'll have some manner of big red marker to point them out.
I sincerely doubt the errors in the test will be mis-spelled variable names or unbalanced parenthesis - that would be completely retarded. Probably more like typical semantic errors that you won't notice unless you have a passable grasp of syntax, not necessarily something the compiler complains about. C and C++ in particular have a lot of stuff that can go wrong silently.No. It's one of the many ways in which the way we teach things differs vastly from the way we use them in the real world.
I remember reading a blog post on some guy's interview process where, after asking a candidate to code something, he asks the candidate to find the bug. And he likes asking the "find the bug" question the most when there's no bug. First he sees if the candidate has too much ego to actually check the code. Then he sees if the candidate has the competence and guts to assert that there is no bug. If they get to that point, he will then try to argue something specific in the code is a bug, and sees whether the candidate can stick to their position, be diplomatic, and counter his bullshit with actual arguments instead of being a yes-man or becoming insufferable. I thought this was a fantastic idea.
Warning or no, that one is a classic.if (a = b)...
That said, these days that sort of thing tends to at least give you warnings. You might argue that if the syntax is correct, it's not a syntax error, of course.
But I was thinking more about stuff like operator precedence, benign-looking things like ++ slipped into a statement where they trigger undefined behavior, "int* foo, bar", and especially getting the &'s and *'s right when messing with raw pointers.I got this at an interview about a month ago. After I wrote some code on the white board and went over it, he said he saw a bug. I went over each line aloud to make sure. In the end I said there were no errors. He was like "lol jk just wanted to see what you'd say"
He still missed the last step where he'd try to argue something you wrote was a bug. That said, it's hard to prepare an argument ahead of time when you don't know exactly how an applicant will solve a problem, and also hard to make up one on the spot that is subtle enough to not be obvious. Gonna take a good interviewer to really pull that off.
If 'A' is always a single character then yeah just use indexes, String has charAt(i). If A can be a variable length... huh...
// Get a reference to the SQLite database
var dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "db.sqlite");
// Initialize the database if necessary
using (var db = new SQLite.SQLiteConnection(dbPath))
{
// Create the table if they dont exist
db.CreateTable<User>();
}var dbPath = Path.Combine(Windows.Storage.ApplicationData.Current.LocalFolder.Path, "db.sqlite");
using (var db = new SQLiteConnection(dbPath))
{
var existing = db.Query<User>("select * from User").First();
if (existing != null)
{
ApiClient.loggedInUser = existing;
NavigationService.Navigate(new Uri("/Pages/Feeds.xaml", UriKind.Relative));
}
}loggedInUser = JsonConvert.DeserializeObject<User>(apiResponseString);
var dbPath = Path.Combine(ApplicationData.Current.LocalFolder.Path, "db.sqlite");
using (var db = new SQLiteConnection(dbPath))
{
db.RunInTransaction(() => { db.Insert(loggedInUser); });
}I don't think anyone mentioned Regular Expressions, but that's also an option.
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PatternMatcher
{
public static void main(String[] args)
{
System.out.println(matcher("A=15;")); // 15
System.out.println(matcher("A=1;")); // 1
}
public static Integer matcher(String match)
{
Pattern pattern = Pattern.compile("A=(\\d+);"); // find digits in this pattern
Matcher matcher = pattern.matcher(match); // match against this string
Integer digit = null;
if (matcher.find()) {
digit = Integer.valueOf(matcher.group(1)); // the first match in parentheses
}
return digit;
}
}public void onClickPower(View v) throws IOException {
if (!ispoweron) {
ispoweron = true;
//Do stuff
}
if (ispoweron) {
ispoweron = false;
//Do stuff
}for (int i = 0; i < objectArray.length; i++)
{
System.out.println(objectArray[i].yourfieldname/getter);
}YourClass selectedObject = objectArray[i]; //Get object at position i
selectedObject.myMethod(); //call one of the methods / use one of the fields of the objectif (powerOn) {
// Do stuff
powerOn = false;
} else {
// Do other stuff
powerOn = true;
}//main
#include <iostream>
#include "node.h"
using namespace std;
using namespace MyNode;//node.h definitions
int main()
{
cout << "a node will be created" << endl;
node* head;
if(head->getNext() == NULL) cout << "the pointer is pointing to absolutely nothing" << endl;
cout << "data will be entered" << endl;
head->setData(10);
cout << "data has been entered" << endl;
cout << head->getData() << endl;
return 0;
}//header
#ifndef NODE_H
#define NODE_H
namespace MyNode
{
//template<class T>
class node
{
public:
node();//imp
~node();//imp
void setData(int inp);
int getData();
void setLink(node* new_next);
node* getNext();
bool isEmpty();//imp
void insert_new_node(const int new_data);
private:
int content;
node* next;
};
}
#endif//implementations
#include "node.h"
#include <iostream>
using namespace std;
namespace MyNode
{
//template<class T>
node::node()
{
cout << "I've entered the constructor!" << endl;
next = NULL;
cout << "I'm here!" << endl;
}
//template<class T>
node::~node()
{
cout << "I've entered the destructor!" << endl;
if(next != 0) delete next;
cout << "Everything is deleted!" << endl;
}
//template<class T>
bool node::isEmpty()
{
if( next == 0) return 1;//if we have a top that's simply a pointer to the first element, this should work
else return 0;
}
//template<class T>
void node::insert_new_node(const int new_data)
{
node* temp;
temp = next;
while(temp != 0) temp = temp->next;
temp->next = new node;
temp->content = new_data;
}
void node::setData(int inp)
{
content = inp;
}
int node::getData()
{
return content;
}
void node::setLink(node* new_next)
{
next = new_next;
}
node* node::getNext()
{
return next;
}
}What line is giving the exception? And did you try just copy-pasting from some JTextField tutorial that you confirmed works, to check what you're doing differently?
JButton jbtStuNms = new JButton(new AbstractAction("Student Names") {
@Override
public void actionPerformed(ActionEvent e) {
// On button press, print only names of just stored students
jtaOutput.append(manager.printStuNames());
}
});public String printStuNames() {
//TODO: Define a way to print only student names
return stuObjects[stuCount].getNme();
}public String getNme() {
// Filler to test methods
return "Hello";
}As you've discovered, node* does not create a node. It's just a pointer to a node, and until you give it a node to point to, it points at random garbage in memory.
NULL is defined in stdlib.h. Library headers are allowed to include other library headers, though, so it's often defined regardless of whether you explicitly include that one.
Just as you saw, if you try to use an uninitialized pointer, you'll get weird results. The best case scenario is that you'll get a crash. The worst case scenario is that your program will continue chugging along, but be subtlely incorrect, or crash at some later point in time when it's less obvious what the real underlying cause was.
Wait.. don't you need to use stuCount-1 there? Maybe I'm missing something.
public String printStuNames() {
//TODO: Define a way to print only student names
System.out.println(stuObjects);
return stuObjects[stuCount].getNme();
}//main
#include <iostream>
#include "node.h"
using namespace std;
using namespace Mynode;//node.h definitions
int main()
{
cout << "a node will be created" << endl;
node<int> head;
head.setData(10);
//similarly, this doesn't work either:
//node<int>* head = new node<int>;
cout << head.getData() << endl;
return 0;
}//header
#ifndef NODE_H
#define NODE_H
namespace MyNode
{
template<class T>
class node
{
public:
node();//imp
~node();//imp
void setData(T inp);
T getData();
void setLink(node<T>* new_next);
node<T>* getNext();
bool isEmpty();//imp
void insert_new_node(const T new_data);
private:
T content;
node<T>* next;
};
}
#endif//implementations
#include "node.h"
#include <iostream>
using std::cout;
using std::endl;
namespace MyNode
{
template<class T>
node<T>::node()
{
cout << "I've entered the constructor!" << endl;
next = NULL;
cout << "I'm here!" << endl;
}
template<class T>
node<T>::~node()
{
cout << "I've entered the destructor!" << endl;
if(next != NULL) delete next;
cout << "Everything is deleted!" << endl;
}
template<class T>
bool node<T>::isEmpty()
{
if( next == NULL) return 1;//if we have a top that's simply a pointer to the first element, this should work
else return 0;
}
template<class T>
void node<T>::insert_new_node(const T new_data)
{
node<T>* temp;
temp = next;
while(temp->next != NULL) temp = temp->next;
temp->next = new node<T>;
temp->content = new_data;
}
template<class T>
void node<T>::setData(T inp)
{
content = inp;
}
template<class T>
T node<T>::getData()
{
return content;
}
template<class T>
void node<T>::setLink(node<T>* new_next)
{
next = new_next;
}
template<class T>
node<T>* node<T>::getNext()
{
return next;
}
}It doesn't matter what you call the file you put them in. The only thing that matters is that file is #include'd wherever something wants to use a node<T>. I just call those files *.h, but some people like to call them *.hpp.
